Climateproof

Climate data you can prove: every CO₂ reading is signed at the source, hash-chained into a Merkle transparency log, and audited by an on-device AI — no trust required.

Comment

Track Alignment

Track 4 — Climate Data & Environmental Monitoring.

Environmental data is fragmented and impossible to verify: readings sit in mutable databases and can be "corrected" after the fact, which undermines carbon markets, national inventories and COP transparency reporting. ClimateProof closes that gap with a Certificate-Transparency-style append-only log: each station signs its readings with a real ECDSA P-256 key, readings are hash-chained into SHA-256 blocks with Merkle inclusion proofs, and every visitor can verify the entire chain in one click in their own browser. An on-device AI trained on 68 years of real NOAA measurements predicts what trustworthy CO₂ should be and flags anomalies — flagged, never deleted, because the anomaly is evidence. The result is blockchain-grade data integrity without a token or a trusted intermediary: practical, auditable and deployable by meteorological services, carbon-market verifiers and journalists today.

Inspiration

Every climate decision — carbon credit integrity, national inventories, loss-and-damage claims, Paris Agreement transparency reports — rests on environmental measurements. Yet those readings live in ordinary mutable databases: a value can be "corrected" after the fact, an inconvenient sensor quietly edited, and a whole dataset disputed with no way to settle the argument. At COP 31, MRV (Measurement, Reporting, Verification) is the foundation of climate accountability — and today that foundation is built on "trust us".

We asked a simple question: what if climate data had the same integrity guarantees as HTTPS? Certificate Transparency has made every TLS certificate independently auditable since 2013, run by Google, Apple and Mozilla, verified by browsers worldwide. We ported that architecture to climate readings.

What it does

ClimateProof is an open, append-only transparency log for environmental readings, with four surfaces:

  • Dashboard — the Keeling curve built from 823 real monthly NOAA Mauna Loa CO₂ measurements (1958–2026), an AI forecast to 2050 with a 95% uncertainty band, and a live feed of stations whose readings are signed in real time.
  • Ledger — hash-linked blocks with Merkle roots and per-entry ECDSA signatures. One button, "Verify entire chain", recomputes every hash, every Merkle root and every signature in the visitor's own browser. Green means green: nothing is taken on faith.
  • Tamper Lab — a working attack simulator. Pick any sealed reading, forge its CO₂ value (e.g. 426 → 350 ppm to make emissions look better), and watch verification fail with a plain-language explanation of which lock tripped: the source signature, the Merkle root, or the hash chain. The honest alternative is shown too: append a signed correction entry — history is corrected, never erased.
  • AI Lab — the forecasting model is not a pretrained black box. It trains in the browser in ~30 ms on every visit, and its full equation is displayed with physical meaning: the quadratic term is the accelerating human fingerprint, the sine pair is the annual biospheric cycle. Backtested on the 10 most recent years it never saw: MAE 0.66 ppm, R² 0.9993.

Three locks protect the record: (1) only the station's private ECDSA key can sign a reading; (2) the reading's hash lives inside the block's Merkle tree, so changing it breaks the root; (3) each block commits to its predecessor, so rewriting one block invalidates every block after it.

How we built it

Zero dependencies, zero backend, zero build step — vanilla HTML, CSS and JavaScript. Cryptography is the browser's native Web Crypto engine: ECDSA P-256 keypairs per station, genuine sign/verify calls, SHA-256 digests, and hand-built Merkle trees with inclusion proofs. Readings are serialized with canonical JSON (sorted keys, no whitespace) so the signed bytes are reproducible across implementations. Blocks seal under a deliberately light proof-of-work anchor (hash must start with 0, ~16 attempts) so judges watch sealing happen instantly. The AI is a 7-parameter physics-informed regression trained by L2-regularized full-batch gradient descent (4,000 epochs). Charts are drawn on Canvas. Data is prepared by a build script from the public NOAA GML dataset. The app is deployed on GitHub Pages and works offline after load.

Challenges we ran into

  • Canonicalization is where cryptography breaks silently: if the JSON that was signed differs by one byte from the JSON that is verified, everything fails mysteriously. Sorting keys deterministically was essential.
  • Merkle proofs across levels look trivial until odd node counts appear — we used the Certificate Transparency rule of duplicating the trailing node, and verified proofs end-to-end in the UI rather than trusting the implementation.
  • Honest ML: it is easy to fit the Keeling curve beautifully and call it a forecast. We held out the last 10 years and report the numbers the model did not see — and the metrics recompute live for every visitor, so nobody has to trust our screenshot.
  • Resisting blockchain theatre: it was tempting to add a token or a "real" chain. We chose the standard, boring, proven primitive — an append-only Merkle log — and stated its limits explicitly (single node; production needs multiple independent logs and witness cosigning).
  • Demo speed: cryptographic verification with async Web Crypto plus PoW sealing had to stay instant enough to feel like a product, not a science experiment.

Accomplishments that we're proud of

  • Real ECDSA signatures, real SHA-256 hash links and real Merkle inclusion proofs — verifiable by any visitor in one click, with no trust in us.
  • A tamper demo that actually works: forging a sealed reading is rejected by three independent mechanisms, and the UI explains why in language a policymaker can follow.
  • An AI model that trains in the browser in tens of milliseconds on 68 years of real measurements, with an honest backtest (MAE 0.66 ppm, R² 0.9993) that is recomputed on every page load.
  • A complete, dependency-free product: 12 MB including the demo video, runs on a 10-year-old laptop, no API keys, no accounts, no data leaving the device.

What we learned

  • Integrity is a UX problem as much as a cryptographic one: showing a forgery failing convinces people far more than claiming the system is secure.
  • Canonical serialization is the hidden failure mode of every signing scheme.
  • Climate records need "append-only plus signed corrections", not deletion — the record of an anomaly is itself evidence.
  • Honest scoping earns trust: stating "this is a single-node log; production is Certificate Transparency with witnesses" turns the strongest objection into a demonstration of understanding.

What's next for ClimateProof

  • Multi-node Certificate-Transparency architecture with witness cosigning, gossip and independent auditors.
  • A station onboarding SDK (ESP32/IoT) that signs readings at the edge, before they ever leave the sensor.
  • Pilot integrations with carbon-market MRV and national inventory workflows (ISO 14064, Paris Agreement ETF).
  • Verification as a public good: a browser extension and a public API so journalists and regulators can check any published reading.
  • Localization for Uzbek and Russian, and a low-bandwidth mode for field stations.

Built With

Share this project:

Updates

Submission history