Verify a Trust Record Independently

​

Goal

​

Prerequisites

• A trust record to verify, saved as JSON. Get one from Quickstart, or reuse any ExecutionTrustRecord you already have on disk.
• Parmana’s public key. Two ways to get it, covering both the local-dev case and the genuine third party case (added 2026-09-11, see below):
  • Already on this machine for local dev: keys/default.public.pem.
  • A real third party (regulator, auditor, customer) who has never touched this deployment’s filesystem fetches it over HTTP instead: GET /keys/default or GET /.well-known/jwks.json (unauthenticated, no API key needed, see Authentication). This is what actually makes the claim below true for someone who isn’t the operator, not just “the server process happens to be stopped on the same box the key file already lives on.” You do not need the private key, default.private.pem, for any step in this guide.
• Read Execution trust records first, this guide verifies exactly the hash and signature that page describes.

​

Steps

​

1. Get a trust record and save it, then stop the server

curl -s -X POST http://localhost:3000/execute \
  -H "Authorization: Bearer $PARMANA_API_KEY" \
  -H "Content-Type: application/json" -d '{ ... }' \
  > trust-record.json

curl -m 3 http://localhost:3000/health
# curl: (7) Failed to connect to localhost port 3000

​

2. Verify it with VerificationCrypto, offline

import { readFileSync } from "node:fs";
import { VerificationCrypto } from "@parmana/crypto";

const trustRecord = JSON.parse(readFileSync("trust-record.json", "utf8"));
const crypto = new VerificationCrypto();

const recomputedHash = await crypto.hash(trustRecord);
const hashMatches = recomputedHash === trustRecord.trustRecordHash;
const signatureValid = await crypto.verifySignature(trustRecord);
const fullyVerified = await crypto.verify(trustRecord);

​

2b. Or: the standalone, zero-config offline verifier (2026-09-11)

import { readFileSync } from "node:fs";
import { verifyExecutionTrustRecordOffline } from "@parmana/crypto";

const trustRecord = JSON.parse(readFileSync("trust-record.json", "utf8"));
const publicKeyPem = readFileSync("default.public.pem", "utf8"); // e.g. fetched via GET /keys/default

const result = await verifyExecutionTrustRecordOffline(trustRecord, {
  default: publicKeyPem,
});
console.log(result); // { valid, hashValid, legacySignatureValid, hybridSignaturesValid?, algorithmsChecked, errors }

​

Verify

Recomputed hash:   4d695da8e1d39d45599fdc0d91561ba680891a9d199d410db7d4d02a8b9ea66d
Stored hash:       4d695da8e1d39d45599fdc0d91561ba680891a9d199d410db7d4d02a8b9ea66d
Hash matches:      true
Signature valid:   true
Fully verified:    true

Recomputed hash:   6ea2874ad4a6db6312d5c2a531edac17b789976af80d07ed01081f2be38cfab5
Stored hash:       4d695da8e1d39d45599fdc0d91561ba680891a9d199d410db7d4d02a8b9ea66d
Hash matches:      false
Signature valid:   false
Fully verified:    false

​

Troubleshoot

• A large record fails to verify in your own implementation. A record over 4096 bytes of canonical content may have been signed by AWS KMS as a fixed 97 byte commitment, because KMS refuses a longer raw Ed25519 message. Build the commitment as the bytes of PARMANA-ED25519-LARGE-MESSAGE-V1, one NUL byte, then the SHA-512 digest of the canonical bytes, and verify the same signature over that. Try the raw signature first, and try the commitment form only when the record is over 4096 bytes, never for a smaller one. verifyExecutionTrustRecordOffline (TypeScript) and verify_execution_trust_record_offline (Python) both do this.
• Public key not found: default. VerificationCrypto resolves keys via PARMANA_KEY_DIR (or ./keys if unset), confirm keys/default.public.pem exists at that path relative to where you run the script.
• Verification fails on a record you’re sure is untampered. Confirm you copied the JSON exactly as returned, re-serializing through a tool that reorders keys or reformats timestamps can change byte-level content even though the JSON is semantically identical, canonical serialization is order-sensitive by design.
• You need this in Python, not TypeScript. The Python SDK’s client.verification.verify() calls POST /verify over HTTP and requires a running server, so it is not offline. As of 2026-09-11, parmana.crypto.verify_execution_trust_record_offline (a separate, standalone module, python/parmana/crypto/offline_verifier.py) does the same offline check as the TypeScript example above, independently reimplemented, not a wrapper around the TypeScript code. Cross-language determinism is proven by python/tests/test_offline_verifier.py, which signs a record with the real TypeScript signer and verifies it with only the Python module. Install it with pip install "parmana[verify]", since the module needs the cryptography package, which the verify extra provides. On 1.4.0 and earlier, pass the record as the plain JSON the server returned, not a decoded model: a decoded record whose previousChainHash is null fails to verify there (G-85, fixed in 1.5.0). Ed25519 only for now: the cryptography package version this SDK depends on has no ml_dsa module yet, so a hybrid-signed record’s ML-DSA-65 signature cannot be checked from Python until that lands upstream; use the TypeScript version for a complete hybrid check today.

​

Next