Timestamp GIT

← All posts

2026-10-31

Why Your Git Log Isn't Proof — and How to Make It Tamper-Proof

Why Your Git Log Isn't Proof — and How to Make It Tamper-Proof
timestamp git blockchain proof

Why Your Git Log Isn’t Proof — and How to Make It Tamper-Proof

Ask yourself a concrete question: if a lawyer, an auditor, or a patent troll’s counsel asked you to prove that a specific commit existed on a specific date, what would you actually hand them?

A screenshot of git log? An export of your GitHub activity? Both are trivially dismissed. If you want real git history tampering proof with Bitcoin, the answer isn’t a better export — it’s a timestamp that nobody, including you, can backdate or alter. This guide walks through the mechanics of why your log fails as evidence, and then the exact steps to make it tamper-evident, with the GitHub App doing the work overnight.

Why Your Git Log Is Not Tamper-Proof (And What That Means for Compliance)

Git is content-addressed, which fools people into thinking history is immutable. It isn’t. Every commit hash is a hash of the tree, parent, message, and metadata — but the chain of those hashes lives in a repository on a server you don’t control. Three things break the evidentiary value:

  • History is rewritable by design. git rebase, git commit --amend, and a force-push will replace commits with new hashes. Old objects linger until garbage collection, and then they’re gone. A maintainer with push rights can rewrite months of history in a minute.
  • The dates are self-reported. Author and committer timestamps are just metadata you can set. Any internal log that records time is only as trustworthy as the machine that wrote it.
  • The log lives on someone else’s infrastructure. Your GitHub organization, your CI database, your internal wiki — all editable, all under your control. In a legal audit, that makes them “self-serving” evidence and easy to challenge.

That last point matters more than developers expect. A record you could have changed is a record the other side will argue you did change. The fix isn’t more logging — it’s externalizing the proof to a system whose history no single party can rewrite.

That’s the idea behind cryptographic prior art: you take the fingerprints Git already produces (commit hashes), batch them, hash the batch again into a Merkle tree, and anchor the root in the Bitcoin blockchain through the OpenTimestamps protocol. Somebody can rewrite your repo, but they cannot rewrite a Bitcoin block.

Timestamp GIT automates this whole chain — no CLI tools, no OpenTimestamps commands, no developer workflow changes. For deeper background, see how to prove prior art for a software idea without a patent and whether a blockchain timestamp is legally valid evidence.

Prerequisites: What You Need Before Anchoring Your First Commit

  • A GitHub repository (public or private) where you have admin rights, so you can install the Timestamp GIT GitHub App.
  • A Timestamp GIT account — free for open source / public repos, Pro Agency ($49/mo) for private repos, Enterprise ZK ($199/mo) for the GitHub Actions mode.
  • A target repository for proofs. Either a branch in the same repo or a separate shadow repo. The GitHub permission model requires at least read-only access to the source repo (there is no “commit hash only” scope), plus read-write on the target.
  • For Enterprise ZK mode: a GitHub Actions workflow and an API key. Here only read-write access to the target repo is required — the source repo needs no read access at all.
  • For self-hosted: Docker and Docker Compose, plus a time-limited demo license from the Docker License page.

Nothing gets installed on developer machines.

Step-by-Step: Make Your Git History Tamper-Proof with Timestamp GIT

Step 1 — Install the GitHub App and connect the repository

Install the Timestamp GIT GitHub App on your organization and select the repositories to monitor. Grant read-only access to source repos and read-write to the target (branch or shadow repo). The app registers webhooks and detects new commits automatically — there’s no per-commit action from your team.

In Standard mode the app reads only the HEAD commit hash of each monitored repository. It never reads the working tree, the diffs, or the file contents.

Step 2 — (Optional) Switch to Enterprise ZK mode

If even a commit hash leaving your network is too much, Enterprise ZK mode replaces the webhook path with a short GitHub Action that runs on your own runners. It pushes only the hash — the service never gets read access to the source repo.

name: Timestamp commit hash
on:
  push:
jobs:
  anchor:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Push HEAD hash to Timestamp GIT
        env:
          TSGIT_API_KEY: ${{ secrets.TSGIT_API_KEY }}
        run: |
          HASH=$(git rev-parse HEAD)
          # POST $HASH + repo metadata to the Timestamp GIT API.
          # The workflow is generated for you by the Enterprise setup wizard
          # at https://timestampgit.dev/enterprise/{phase}.

That’s the entire surface area: one hash, one authenticated request.

Step 3 — Let the nightly cron worker do the anchoring

You do nothing here. Every night, a worker:

  1. Groups all pending commit hashes from the in-memory queue.
  2. Builds a manifest .txt per repository.
  3. Constructs a Merkle tree natively over the batch.
  4. Creates OpenTimestamps proofs using public OTS calendars.
  5. Anchors the Merkle root into the Bitcoin blockchain.

Batching is the point — a thousand commits across a hundred repos cost one anchor.

Step 4 — Collect the .ots receipts and manifests

After Bitcoin confirmation, the manifest and .ots receipt files are pushed back to your dedicated timestamps branch or shadow repo. Bitcoin confirmation typically takes around 3 hours, so proofs land a few hours after the nightly run — not instantly. Plan your expectations accordingly, especially if you’re demoing this to compliance.

Step 5 — Embed a verification badge

Grab the snippet from your repository connected page (/connected/{user}/{repo}), which renders a live Shields.io preview:

[![Bitcoin timestamped](https://img.shields.io/endpoint?url=https://timestampgit.dev/api/statusSummary/acme/payments-service)](https://timestampgit.dev/status/acme/payments-service)

Anyone clicking through lands on the public status dashboard. Private repos append an encrypted HMAC to the URL — instance-specific — so only authorized viewers see the data.

Step 6 — (Alternative) Self-host with Docker Compose

For air-gapped or maximum-control environments, the same pipeline runs 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. On first launch, a setup wizard walks you through connecting your GitHub App and configuring the instance. Drop your demo license from the Docker License page into place when prompted.

How to Confirm It Worked: Verification and Audit Trails

Four checks, in increasing order of rigor:

1. The status dashboard. Visit /status/{user}/{repo} for proof longevity, earliest anchor date, daily regularity, and the Bitcoin block and transaction data behind each batch. A calendar heatmap makes gaps obvious — useful when an auditor asks “was this continuous?”

2. The verification page. /verification/{user}/{repo}/{date} walks you through the multi-level Merkle chain step by step. All computation happens locally in your browser: zero-knowledge, and nobody sees what you verify. This is the page to open in a meeting when someone questions the timestamp.

3. Audit exports. Pull structured records for compliance:

# Full audit ledger as CSV
curl -O https://timestampgit.dev/api/audit/acme/payments-service

# PDF certificate for a specific anchored date
curl -OJ https://timestampgit.dev/api/report/acme/payments-service/2026-10-30

# Raw Merkle chain data for local verification
curl https://timestampgit.dev/api/verify/acme/payments-service/2026-10-30

4. Independent verification. Because the proof relies only on SHA-256 and Bitcoin block data, anyone can verify a .ots receipt against the blockchain with standard OpenTimestamps verification tools — offline, without Timestamp GIT. That’s the vendor-independence guarantee: if the company disappears tomorrow, your proofs still verify.

Troubleshooting Common Issues

  • App installed but nothing is monitored. Recheck permissions: read-only on source, read-write on target. Enterprise ZK mode is the exception — it needs only read-write on the target and no read access to the source.
  • Proofs “missing” after a push. They aren’t. Bitcoin confirmation takes several hours and the proof files are written afterward. Check the status page for pending anchors before filing a bug.
  • Badge returns 404 on a private repo. The URL includes an encrypted HMAC specific to your server instance. Copy the link from /api/badgeLink/{user}/{repo} rather than constructing it by hand.
  • Self-hosted container starts but the wizard fails. Confirm ./data is mounted correctly and writable, then check docker compose logs -f timestampgit. Most first-run failures are a permissions or volume issue, not the app.

FAQ

Can I still rewrite Git history after using Timestamp GIT? Yes — you can rebase, amend, or force-push locally. But the anchored commit hashes in Bitcoin remain immutable. Any tampering with the original commits becomes evident, because the Bitcoin-anchored hashes won’t match the altered history.

Does Timestamp GIT have access to my source code? No. In Standard mode, the GitHub App reads only the HEAD commit hash. In Enterprise ZK mode, a GitHub Action pushes only the commit hash to the API. Your source code never leaves your environment.

What happens if Timestamp GIT goes out of business? Your proofs are vendor-independent. The .ots receipt files plus Bitcoin blockchain data let anyone verify the timestamp offline using standard OpenTimestamps tools, without relying on Timestamp GIT.

How long does it take for a commit to be anchored? Commits are batched nightly. After the batch is anchored, Bitcoin confirmation typically takes around 3 hours, and the proof files are written a few hours later. You’ll find the .ots receipts in your repository’s timestamps branch.

Conclusion

Your Git log is an operational record, not evidence. It sits on infrastructure you control, contains dates you can set, and can be rewritten by anyone with push rights — which is exactly why auditors discount it. Anchoring commit hashes into Bitcoin converts that record into something outside your control and outside your ability to alter.

Timestamp GIT does it without asking your developers to learn a protocol: install the GitHub App once, let the nightly worker anchor, embed the badge, and keep the .ots receipts and audit exports for the day you actually need them.

Next step: install the app on your most business-critical repository today. The oldest anchor you’ll ever have is the one you create tonight.

Related posts

EU label: AI-generated content