Timestamp GIT

← All posts

2026-11-02

Git Commit Timestamps Aren't Tamper-Proof — What Is

Git Commit Timestamps Aren't Tamper-Proof — What Is
timestamp git blockchain proof

Git Commit Timestamps Aren’t Tamper-Proof — What Is

Open your terminal and run git log. You’ll see a date next to every commit. Now imagine a lawyer, an auditor, or the CTO of the company acquiring you asking a simple follow-up question: “How do I know that date is real?”

The honest answer is that you can’t prove it. Not with git log, not with your GitHub activity feed, not with your internal audit database. Those are all records you control, and records you control can be edited. This article explains what “tamper-proof” actually means, why Git timestamps fail the test, and how cryptographic anchoring to Bitcoin fixes it — automatically, via Timestamp GIT.

The Question: Can You Really Trust a Git Commit Timestamp?

Every Git commit carries two timestamps: the author date and the committer date. Here’s how to see both:

git log -1 --format='commit  %H%nauthor  %an <%ae>  %ad%ncommitter %cn <%ce>  %cd' --date=iso

Those dates come from the clock on the machine that ran git commit. They are inputs, not observations. Git does not consult a trusted time source, and it does not attest to anything externally.

Which means you can set them to whatever you like:

GIT_AUTHOR_DATE="2026-01-14T09:12:00+00:00" \
GIT_COMMITTER_DATE="2026-01-14T09:12:00+00:00" \
git commit -m "Add billing reconciliation job"

This isn’t an exploit. It’s documented, intentional behavior — the same mechanism that lets you import an old repository with its original history intact.

So when we say tamper-proof, we mean something specific and strict:

  • No one — not a colleague, not a platform admin, not an attacker, and not even you — can alter the record after the fact.
  • Anyone can verify it without having to trust the party that produced it.

Git timestamps satisfy neither condition. Here’s why, and what does.

Why Git Timestamps Are Tamper-Proof in Theory Only

Git’s integrity model is a hash chain. Each commit contains its parent’s hash, so changing any commit’s content changes every hash downstream. That’s real cryptographic integrity — for content.

The timestamp is just a field inside the commit object. Nothing external pins the commit’s existence to a point in time. The chain proves “this content is consistent with this history,” not “this content existed on this date.”

Anyone with write access can rewrite the history and the dates along with it:

# Amend the most recent commit with an arbitrary date
git commit --amend --no-edit --date="2025-06-01T08:00:00"

# Rewrite every commit in every branch with a new date
git filter-branch --env-filter '
  export GIT_AUTHOR_DATE="2025-06-01T08:00:00"
  export GIT_COMMITTER_DATE="2025-06-01T08:00:00"
' -- --all

Even on hosted platforms, a force-push replaces history wholesale. And platform-side logs — webhook deliveries, audit trails, activity feeds — live in databases that admins and attackers can reach. In a dispute, “we have it in our own logs” is exactly the kind of evidence opposing counsel dismisses as self-serving.

The analogy: a Git timestamp is a date written in pencil in your own diary. It might be perfectly accurate. It might be the most honest diary in the world. But anyone holding an eraser can change it, and no third party saw you write it. Cryptographic anchoring is the equivalent of walking that diary page to a notary and having it stamped into a public ledger that nobody — including the notary — can rewrite afterward.

How Cryptographic Anchoring Makes Timestamps Tamper-Proof

The fix is to take the fingerprint of your work and publish it somewhere you don’t control. That’s it. That’s the whole idea.

Step 1 — The fingerprint

When you commit, Git hashes the entire repository state into a unique identifier (SHA-1 or SHA-256). That hash is a one-way fingerprint: it identifies your exact code state without revealing anything about the code itself.

Step 2 — The anchor

Timestamp GIT collects the commit hashes for a repository into a daily manifest file, hashes that manifest, builds a Merkle tree over the batch, and embeds the Merkle root into a Bitcoin transaction using the OpenTimestamps protocol. Bitcoin’s blockchain is append-only and replicated across thousands of nodes — once your root is confirmed in a block, the record of “this hash existed by this date” is permanent.

Step 3 — The proof

You get an immutable .ots receipt file. It chains your commit hash up through the Merkle tree to a specific Bitcoin block. Anyone can walk that chain against the public blockchain and confirm the timestamp — without trusting you, and without trusting Timestamp GIT.

That last point matters more than it sounds. The product’s guarantees are deliberately boring:

  • Zero-knowledge: your source code is never read, copied, or stored. Only hashes leave your repository.
  • Vendor independent: the proof uses SHA-256 and Bitcoin block data. No proprietary format, no lock-in. If Timestamp GIT disappeared tomorrow, your .ots files would still verify.
  • Nothing to install on developer machines.

The hard way to get here is to drive the OpenTimestamps protocol and Bitcoin transactions yourself — a project in its own right, covered separately in Timestamp GIT vs OpenTimestamps CLI. Timestamp GIT exists so you don’t have to.

Why This Matters: Common Misconceptions and Real Risks

Misconception: “Git timestamps are good enough for an audit.” Internal logs are routinely discounted as manipulatable. An audit trail you generate and store yourself proves intent, not existence.

Misconception: “Blockchain timestamps are only for crypto projects.” Any commit hash can be anchored — a Rails monolith, a firmware repo, an internal trading system. The technology doesn’t care what’s in the code.

Misconception: “We’d know if someone changed our history.” Force-pushes, rebases, and admin-level edits are quiet by design. Unless you’re diffing every ref against an external record, you wouldn’t.

The real risks are concrete:

  • Patent trolls. A non-practicing entity files a broad patent on something you shipped months earlier. Without dated, independently verifiable proof, you’re arguing from memory.
  • Employee and contractor disputes. When a lead developer leaves, “when was this feature actually built?” turns into a credibility contest. An immutable timestamp ends it.
  • “Clean room” claims. A competitor says they developed similar logic independently. Proving you had finished, working code 18 months earlier creates a wall they can’t climb.
  • Compliance and trade secrets. Auditors and legal teams increasingly want proof of existence for IP and internal systems — without publishing the source.

How Timestamp GIT Automates Tamper-Proof Timestamps

Here’s the part where the cryptography stops being your problem.

Install once, anchor nightly

Install the GitHub App on the repositories you want protected. It detects new commits via webhooks. From then on, there are no commands to run, no files to manage, no developer workflow changes — every commit is anchored automatically each night.

Under the hood, pending hashes queue up in an in-memory key-value store. At midnight, a worker groups them, writes a .txt manifest per repository, builds the Merkle tree, and anchors the root into Bitcoin through public OpenTimestamps calendars. Bitcoin confirmation normally takes around three hours, so the finished proofs land back in your repository a few hours after the nightly run.

Proofs land in your repo

The manifest and .ots receipt files are pushed to a dedicated timestamps branch, or to a separate shadow repository if you prefer to keep them out of the source repo. In standard mode the GitHub App needs read-only access to the source repo and read-write access to the target repo.

Verify without trusting anyone

  • README badges show live verification status, with a link anyone can follow to check it.
  • The repository status dashboard (/status/{user}/{repo}) exposes proof longevity, earliest anchor date, daily regularity, Bitcoin block and transaction data, a calendar heatmap, and downloadable audit CSV and PDF certificate.
  • The verification page (/verification/{user}/{repo}/{date}) walks through the full multi-level Merkle chain — all computation happens locally in your browser, so nobody sees what you verify.
  • The REST API gives you the same data programmatically:
# Last anchored Bitcoin block for a repository (public)
curl -s https://timestampgit.dev/api/statusLast/acme/payments-api | jq

# Total stamped commit count (public)
curl -s https://timestampgit.dev/api/statusCount/acme/payments-api | jq

# Full audit ledger as CSV (used for compliance exports)
curl -sL https://timestampgit.dev/api/audit/acme/payments-api -o audit-ledger.csv

Private repositories append an encrypted HMAC to these URLs, scoped to your server instance, so only authorized users can read their status.

Enterprise ZK mode

If your security policy forbids granting a third party repository access at all, Enterprise ZK mode swaps the GitHub App for a small GitHub Action that runs on your own infrastructure. The Action pushes commit hashes to the Timestamp GIT API; the target repo still receives the proofs. Your source repository is never read.

Self-hosted Docker for air-gapped environments

For maximum control, 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 application is available at http://localhost:8080 after startup. On first launch, a setup wizard walks you through connecting your GitHub App and configuring the instance. A time-limited demo license is available by submitting the request form on the Docker License page.

FAQ

Can I change a Git commit timestamp after the fact? Yes, Git timestamps are just metadata set by the committer’s machine. You can amend a commit with git commit --amend --date, rewrite history with git rebase, or edit the commit object directly. Even on hosted platforms like GitHub, force-pushes can alter timestamps, so they are not tamper-proof on their own.

How does Bitcoin anchoring make a timestamp tamper-proof? Timestamp GIT takes your commit hashes, builds a Merkle tree, and embeds the root into a Bitcoin transaction via OpenTimestamps. Once confirmed in a Bitcoin block, the timestamp is immutable — no one, including Timestamp GIT, can alter it. You receive an .ots receipt that can be verified against the Bitcoin blockchain by anyone.

Do I need to run any OpenTimestamps commands to use Timestamp GIT? No. Timestamp GIT is a managed service: you install the GitHub App once, and it automatically anchors your commits nightly. There’s no CLI, no manual stamping, and no need to learn the OpenTimestamps protocol. For air-gapped environments, a Docker self-hosted option is available.

Is a Bitcoin-anchored timestamp legally valid evidence? Cryptographic timestamps provide strong proof of existence that is increasingly accepted in legal contexts, but validity depends on jurisdiction and how the evidence is presented. Timestamp GIT provides court-ready .ots receipts and PDF certificates that you can share with lawyers or auditors. For a deeper discussion, see Is a Blockchain Timestamp Legally Valid Evidence?

The Bottom Line

A Git timestamp is a claim. A Bitcoin-anchored timestamp is evidence. The gap between the two is the difference between saying “we built this first” and being able to prove it years later, in front of people who have every reason to doubt you.

The good news is that closing that gap no longer requires a cryptography project. Install the GitHub App once, let it anchor your commits every night, and keep the .ots receipts — plus an embeddable badge, a public status dashboard, and a PDF certificate for whoever asks.

Plans start with a free tier for public repositories, Pro Agency at $49/mo for private repos, and Enterprise ZK at $199/mo for teams that need the GitHub Action workflow. Pick the one that matches your repo visibility and get your first anchor tonight.


Related posts

EU label: AI-generated content