# How a signing record stays tamper-evident, step by step

> How a tamper-evident record is built: salted SHA-256 hash, append-only hash-chained ledger, ES256 receipt, RFC 3161 timestamp, Merkle log, offline verifier.

Source: https://esigncomply.com/why/immutable-record

How the record is sealed

You vibe coded the signing page. Good. This page is about what happens behind it. Each record goes into an append-only, hash-chained ledger: entries are only ever added, and any change breaks the chain, the signature and the outside timestamp. Here is every step, and how anyone checks the result offline.

[Get started](https://esigncomply.com/signup) · [Reference version](https://esigncomply.com/product/evidence)

receipt.jws, decoded payload

```
{
  "iss": "https://esigncomply.com",
  "rid": "rec_Z4m8",
  "dom": "example.com",
  "hash": "sha256:5be7...",
  "iat": 1795273400,
  "lvl": "simple",
  "asr": "L1",
  "seq": 18244,
  "prev": "sha256:a91c...",
  "live": true
}
```

## Seven steps from the signer's click to a sealed record

The first three finish inside the request that completes the signature. The record is evidence from that moment. The next four add proof of time and proof that nothing was removed.

recorded · timestamped · anchored

A record moves through three states as the steps complete. Your server gets a webhook at each one: `record.completed`, `record.timestamped`, `record.anchored`.

[The same pipeline in the product reference](https://esigncomply.com/product/evidence#sealing)

1. **Canonical JSON, then a salted SHA-256 hash**

   The record is serialized as canonical JSON (RFC 8785), so the same record always gives the same bytes. We add a random 256-bit salt and compute `SHA-256(salt || record.json)`. The hash covers every event, every document hash and the profile version.

2. **An entry in a ledger that only appends**

   In the same database transaction, an entry is added to the ledger for your domain. It holds the record hash and the hash of the entry before it. Application roles cannot update or delete an entry.

3. **A receipt signed with keys you do not hold**

   We sign a receipt (JWS, ES256) over the record ID, the record hash, the signed-at time, your domain, the ledger sequence and the previous-entry hash. The public keys, current and retired, are published at `/.well-known/jwks.json`.

4. **A timestamp from an outside authority**

   An RFC 3161 timestamp authority outside Esign Comply issues a token over the record hash. It states that this hash existed no later than the authority's time. The target is under 60 seconds after signing.

5. **A Merkle log with a signed checkpoint each minute**

   Ledger entries become leaves of a per-region Merkle tree (the RFC 6962 construction). Each minute we sign a checkpoint: tree size, root hash, previous root, time. Checkpoints chain to each other.

6. **A public anchor each hour**

   Each hour a commitment to the checkpoints goes to a public anchor outside Esign Comply. It holds hashes only. From then on, rewriting the ledger means contradicting something already public.

7. **An inclusion proof for your record**

   We compute the path from your ledger entry to its checkpoint root. The evidence package carries that proof with the receipt, the timestamp token and the public keys.

## What immutable means here: what breaks when something changes

Immutable here is something you check, not something you take on trust. The ledger only grows, and every way of changing the past is caught by a check that someone outside Esign Comply can run. That includes changes made by Esign Comply staff.

What breaks when a sealed record or its ledger is changed, and which verifier check reports it

| If someone… | What breaks | Reported by |
| --- | --- | --- |
| Edits one field of the stored record | SHA-256 over the salt and the record bytes no longer equals the hash in the seal. | Record hash |
| Recomputes the hash after the edit | The receipt names the original hash, and its ES256 signature covers that hash. | Receipt |
| Signs a new receipt with a key of their own | The key is not one of the sealing keys published at `/.well-known/jwks.json`. | Receipt, with `--jwks` |
| Says the record was made at another time | The RFC 3161 token covers this exact hash and carries the outside authority's own time. | Timestamp |
| Deletes or reorders a ledger entry | Every entry names the hash of the one before it, and every checkpoint names the previous root. The chain stops recomputing. | Inclusion proof, and consistency proofs from the public log |
| Rewrites the ledger and signs new checkpoints | The new roots match neither the checkpoints already inside exported packages nor the public anchor published each hour. | The public log and the public anchors |

A sealed record is fixed. Later facts, such as a signer's dispute or a withdrawal of consent, are added beside it as their own ledger entries with their own receipts. Nothing is written inside it.

## Edit a row. Then edit a record.

The same one-line change, made to an acceptance in your own table and to a record in an exported package.

`public.acceptances`

### Your row accepts the edit

psql

```
update public.acceptances
set accepted_at = '2026-11-21 15:03:20+00'
where user_id = 'user_7c1d';
-- UPDATE 1
```

- Postgres does what it is told. The row now says whatever the statement said.
- No other system holds a second copy to compare against.
- A hash column next to it can be updated by the same statement.

rec_Z4m8 · record.json

### The record reports it

Terminal, after one byte of record.json changed

```json
$ npx esigncomply-verify rec_Z4m8.zip
Evidence package rec_Z4m8

FAIL  Manifest     Record.json does not match its sha256.
FAIL  Record hash  Sha256(salt || record.json) is sha256:c41d…, seal.json states sha256:5be7….

Result: NOT VERIFIED (failed: Manifest, Record hash)
```

- The recomputed hash differs from the hash in the seal.
- The receipt still names the original hash, and you cannot sign a new one.
- The outside timestamp and the checkpoint cover the original hash too.

**Your table trusts whoever holds the password. The record trusts arithmetic.**

## Verify an evidence package offline

Anyone you give the package to runs `esigncomply-verify` on their own machine. It checks the package with public keys and the timestamp authority's certificates only, and it keeps working if neither Esign Comply nor your company is around to ask.

**Export and verify**

```
# Download the package (the response holds a short-lived signed URL)
curl -s https://esigncomply.com/v1/records/rec_Z4m8/evidence \
  -H "Authorization: Bearer $ESIGNCOMPLY_API_KEY" | jq -r .url | xargs curl -s -o rec_Z4m8.zip

# Verify with the keys bundled in the package
npx esigncomply-verify rec_Z4m8.zip

# Verify against the published keys and your own timestamp trust anchors
npx esigncomply-verify rec_Z4m8.zip \
  --jwks https://esigncomply.com/.well-known/jwks.json \
  --tsa-roots roots.pem
```

**Output**

```
Evidence package rec_Z4m8
Mode: LIVE

PASS  Manifest                    17 files are present and match manifest.json.
PASS  Record hash                 sha256:5be7… = sha256(salt || record.json).
PASS  Receipt                     ES256 signature by key esc-us-live-2026-11 (live), checked against the keys supplied by the caller; …
PASS  Ledger entry                Entry 18244 of the live ledger recomputes to sha256:… and names the record hash.
PASS  Timestamp                   RFC 3161 token over the record hash, 2026-11-21T15:03:22.000Z, signed by "…", serial …
PASS  Timestamp authority chain   Chain: … (trust anchor). Valid at 2026-11-21T15:03:22.000Z.
PASS  Inclusion proof             The ledger entry is leaf 48121 of 48130 under signed checkpoint chk_…
PASS  Documents                   2 of 2 document files match the content hashes sealed in record.json.
SKIP  Annotations                 The package holds no annotations.
SKIP  Customer-supplied material  The package holds no customer-supplied material.

Result: VERIFIED
```

**By hand (Python)**

```python
# The record hash, recomputed with nothing but the standard library
import base64, hashlib, json

seal = json.load(open("seal.json"))
salt = base64.urlsafe_b64decode(seal["salt"] + "==")
print("sha256:" + hashlib.sha256(salt + open("record.json", "rb").read()).hexdigest())
print(seal["record_hash"])  # the two lines must be equal
```

**Public log**

```
# The latest signed checkpoint. Public, hashes only.
curl https://esigncomply.com/v1/log/checkpoint

# A proof that a larger tree only appends to a smaller one
curl "https://esigncomply.com/v1/log/proof?first=48130&second=52004"
```

### No account, no network

The verifier fetches nothing unless you pass an `https` URL to `--jwks`.

### Open source

MIT licensed, a command-line tool and a library on Web Crypto. Read every check it runs.

### Your own trust anchors

Pass `--jwks` to check signatures against the published sealing keys, and `--tsa-roots` to chain the timestamp to a root you chose.

### A plain result

Each check prints PASS, FAIL or SKIP with the reason. A skipped check is never counted as a pass. The exit code is 0 only when verified.

Test records run the same pipeline with a test key, and the verifier labels them as test. On the Free plan a test record gets a simulated timestamp. Live records on every plan, Free included, get the outside timestamp. [Read the verifier docs](https://esigncomply.com/docs/sdk/verify).

## When someone says you wrote the record afterward

The customer disputing an auto-renewal has a second line of attack: you run the database, so you could have created the acceptance last week. Here is what you can answer.

`public.acceptances`

### With a row in your own table

- A backdated insert and an honest one produce the same row.
- Your database logs and backups are yours too.
- The answer comes down to your word that you did not.

`rec_Z4m8.zip`

### With the sealed record

- They run `npx esigncomply-verify rec_Z4m8.zip` on their own machine, against the published keys.
- The outside authority's token states that this exact record hash existed by 15:03:22 UTC on the day of signup.
- The ledger entry sits at sequence 18244, under a checkpoint signed that same minute, between the entries made before and after it.

The record lets you show what was presented, what the signer did and when, and that none of it changed since. Who keeps it matters as much as how it is sealed. [Read why a third party keeps the record](https://esigncomply.com/why/third-party-record).

## You build the page. This runs behind it.

None of the steps above is code you write. Your AI tool builds the interface and calls complete(), and the sealing happens on our side when the signer finishes.

Start here

### Seal a test record

Create a session, attach the SDK to your own checkbox and button, and download the evidence package for the record it returns.

[Read the quickstart](https://esigncomply.com/docs/quickstart)

Vibe code it

### Build the interface with a prompt

Generate one prompt for Cursor, Claude Code, v0, Lovable, Bolt or Replit. Building a full signing product is the same call, once per signer.

[Generate a prompt](https://esigncomply.com/product/prompt-generator) · [Build your own signing app](https://esigncomply.com/build)

Included

### Every record is sealed this way

The receipt, the evidence report and the evidence package are included on every plan, with no charge per download. The Free plan covers 10 live signatures a month and a full test mode.

[See pricing](https://esigncomply.com/pricing)

## Why this is the part not to vibe code

- The main argument

  **[Vibe code the interface, not the record](https://esigncomply.com/why)**

  What to build with your AI tool, and the two parts to hand off.

  Read it

- Who keeps it

  **[Why a third party keeps the record](https://esigncomply.com/why/third-party-record)**

  You are a party to the agreement. See what changes when someone who is not holds the evidence.

  Read it

- What goes wrong

  **[7 things AI coding tools get wrong](https://esigncomply.com/learn/vibe-coded-esignature-mistakes)**

  Pre-checked boxes, vague notices, links to terms that change, and four more, each as code with the fix.

  Read it

## Questions about tamper-evident records

### What makes a signing record tamper-evident?

Any change to it is detectable. Esign Comply hashes the canonical record with a salted SHA-256, chains that hash into an append-only ledger, signs a receipt over it with ES256 keys you do not hold, and gets an RFC 3161 timestamp from an outside authority. Change one byte and the hash, the signature and the timestamp stop matching.

### Is the record immutable?

The ledger is. Entries are only ever added, each entry names the hash of the one before it, and a signed Merkle checkpoint each minute plus a public anchor each hour fix the order. Later facts, such as a signer's dispute, are added beside a record as entries of their own and never written inside it.

[Evidence and verification reference](https://esigncomply.com/product/evidence)

### How do I verify a record without trusting Esign Comply?

Export the evidence package and run npx esigncomply-verify rec_Z4m8.zip. The open-source verifier recomputes the record hash, the receipt signature, the ledger entry, the timestamp token and the Merkle inclusion proof with public keys only. It needs no account and no network access.

[Verification in the docs](https://esigncomply.com/docs/concepts/verification)

### What is an RFC 3161 timestamp, and why does the record have one?

It is a signed token from a timestamp authority stating that a given hash existed no later than the authority's time. Esign Comply requests one over each live record hash from an authority outside Esign Comply, so the time on the record rests on neither your server's clock nor ours.

### Can I read the public log myself?

Yes. GET /v1/log/checkpoint returns the latest signed checkpoint, and GET /v1/log/proof returns inclusion and consistency proofs. Both endpoints are public and return hashes only. Compare the checkpoint inside an evidence package with the log to see that the log still extends the tree your record was sealed in.

[Seal a test record with the quickstart](https://esigncomply.com/docs/quickstart)

## Seal every signature. Check any of them yourself.

[Get started](https://esigncomply.com/signup) · [Documentation](https://esigncomply.com/docs)

Free plan: 10 live signatures a month and a full test mode. No card required.

---

Every page on esigncomply.com has a Markdown version at the same URL plus `.md` (the home page is `https://esigncomply.com/index.md`). https://esigncomply.com/llms.txt lists them.
