@hcs-witness/verify 0.0.0 → 1.0.0

package/dist/verify.js

@@ -0,0 +1,145 @@
+import { createPublicKey, verify as cryptoVerify } from "node:crypto";
+import { ml_dsa65 } from "@noble/post-quantum/ml-dsa.js";
+import { b64urlToBytes } from "./base64.js";
+import { canonicalBytes } from "./jcs.js";
+import { isKeyset, } from "./keyset.js";
+import { isProof, signedPayload } from "./schema.js";
+export const ML_DSA_CONTEXT = new TextEncoder().encode("gateguard:proof:v1");
+const SIGNALS_MAX_BYTES = 8192;
+const ES256_SIG_BYTES = 64;
+const MLDSA_SIG_BYTES = 3309;
+/** Ordre du groupe P-256 (secp256r1) — constante publique NIST. */
+const P256_ORDER = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551n;
+function parseTime(value) {
+    const t = Date.parse(value);
+    return Number.isNaN(t) ? Number.NaN : t;
+}
+function keyCoversIssuance(key, issuedMs) {
+    const nb = parseTime(key.not_before);
+    if (Number.isNaN(nb) || issuedMs < nb)
+        return false;
+    const na = key.not_after === undefined ? undefined : parseTime(key.not_after);
+    return na === undefined || Number.isNaN(na) || issuedMs <= na;
+}
+export function verifyProof(proof, keyset, opts) {
+    const errors = [];
+    const fail = (codes) => ({
+        valid: false,
+        errors: codes,
+    });
+    if (typeof proof !== "object" || proof === null || Array.isArray(proof)) {
+        return fail(["SCHEMA_INVALID"]);
+    }
+    const v = proof.v;
+    if (v !== 1 && v !== 2) {
+        return fail(v === undefined ? ["SCHEMA_INVALID"] : ["UNSUPPORTED_VERSION"]);
+    }
+    if (!isProof(proof)) {
+        return fail(["SCHEMA_INVALID"]);
+    }
+    const p = proof;
+    const issuedMs = parseTime(p.issued_at);
+    const expiresMs = parseTime(p.expires_at);
+    if (Number.isNaN(issuedMs) || Number.isNaN(expiresMs)) {
+        errors.push("SCHEMA_INVALID");
+    }
+    else if (expiresMs <= issuedMs) {
+        errors.push("TIMESTAMPS_INCOHERENT");
+    }
+    if (p.signals !== undefined) {
+        try {
+            if (canonicalBytes(p.signals).length > SIGNALS_MAX_BYTES) {
+                errors.push("SCHEMA_INVALID");
+            }
+        }
+        catch {
+            errors.push("SCHEMA_INVALID");
+        }
+    }
+    if (!isKeyset(keyset)) {
+        errors.push("KEYSET_INVALID");
+        return { valid: false, errors, proof_id: p.proof_id };
+    }
+    const ks = keyset;
+    const esKey = ks.keys.find((k) => k.alg === "ES256" && k.kid === p.sig.es256.kid);
+    const mlKey = ks.keys.find((k) => k.alg === "ML-DSA-65" && k.kid === p.sig.mldsa65.kid);
+    if (esKey === undefined)
+        errors.push("ES256_KID_UNKNOWN");
+    if (mlKey === undefined)
+        errors.push("MLDSA_KID_UNKNOWN");
+    if (!Number.isNaN(issuedMs) &&
+        ((esKey !== undefined && !keyCoversIssuance(esKey, issuedMs)) ||
+            (mlKey !== undefined && !keyCoversIssuance(mlKey, issuedMs)))) {
+        errors.push("KEY_NOT_VALID_AT_ISSUANCE");
+    }
+    let payload;
+    try {
+        payload = signedPayload(p);
+    }
+    catch {
+        errors.push("SCHEMA_INVALID");
+        return { valid: false, errors, proof_id: p.proof_id };
+    }
+    if (esKey !== undefined) {
+        const sig = b64urlToBytes(p.sig.es256.value);
+        if (sig?.length !== ES256_SIG_BYTES) {
+            errors.push("ES256_SIG_INVALID");
+        }
+        else {
+            const s = BigInt(`0x${[...sig.subarray(32)].map((b) => b.toString(16).padStart(2, "0")).join("")}`);
+            if (s > P256_ORDER / 2n) {
+                errors.push("ES256_HIGH_S");
+            }
+            else {
+                let ok = false;
+                try {
+                    const pub = createPublicKey({
+                        key: {
+                            kty: "EC",
+                            crv: "P-256",
+                            x: esKey.x,
+                            y: esKey.y,
+                        },
+                        format: "jwk",
+                    });
+                    // Signature brute r‖s (IEEE P1363) sur SHA-256(payload).
+                    ok = cryptoVerify("sha256", payload, { key: pub, dsaEncoding: "ieee-p1363" }, sig);
+                }
+                catch {
+                    ok = false;
+                }
+                if (!ok)
+                    errors.push("ES256_SIG_INVALID");
+            }
+        }
+    }
+    if (mlKey !== undefined) {
+        const sig = b64urlToBytes(p.sig.mldsa65.value);
+        const pub = b64urlToBytes(mlKey.pub);
+        if (sig?.length !== MLDSA_SIG_BYTES) {
+            errors.push("MLDSA_SIG_INVALID");
+        }
+        else {
+            let ok = false;
+            try {
+                ok =
+                    pub === null
+                        ? false
+                        : ml_dsa65.verify(sig, payload, pub, {
+                            context: ML_DSA_CONTEXT,
+                        });
+            }
+            catch {
+                ok = false;
+            }
+            if (!ok)
+                errors.push("MLDSA_SIG_INVALID");
+        }
+    }
+    if (opts?.now !== undefined &&
+        !Number.isNaN(expiresMs) &&
+        opts.now.getTime() > expiresMs) {
+        errors.push("PROOF_EXPIRED");
+    }
+    return { valid: errors.length === 0, errors, proof_id: p.proof_id };
+}

package/package.json

@@ -1,8 +1,73 @@
 {
   "name": "@hcs-witness/verify",
-  "version": "0.0.0",
-  "description": "Placeholder reserving the name. Use version 1.0.0 or later, published with provenance from https://github.com/hcs-witness/verify",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "Offline verification library and CLI for HCS Witness proofs. Zero network access.",
   "license": "Apache-2.0",
-  "repository": { "type": "git", "url": "git+https://github.com/hcs-witness/verify.git" },
-  "files": ["README.md"]
+  "author": "AI Solution",
+  "engines": {
+    "node": ">=22"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "hcs-witness-verify": "bin/hcs-witness-verify.mjs"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hcs-witness/verify.git"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "keywords": [
+    "hcs-witness",
+    "proof",
+    "verification",
+    "offline",
+    "es256",
+    "ml-dsa-65",
+    "opentimestamps",
+    "merkle"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc --noEmit -p tsconfig.json && tsc --noEmit -p tsconfig.test.json",
+    "test": "vitest run",
+    "test:cov": "vitest run --coverage",
+    "format:check": "prettier --check .",
+    "format": "prettier --write .",
+    "lint": "eslint . --max-warnings 0",
+    "knip": "knip"
+  },
+  "dependencies": {
+    "@noble/post-quantum": "0.7.1",
+    "canonicalize": "5.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "24.19.2",
+    "@vitest/coverage-v8": "5.1.0",
+    "eslint": "9.39.5",
+    "typescript-eslint": "8.72.1",
+    "fast-check": "4.10.2",
+    "knip": "6.44.1",
+    "prettier": "3.9.10",
+    "typescript": "6.0.3",
+    "vitest": "5.1.0"
+  }
 }