@sanning/proof 0.9.0 → 0.9.1

package/dist/verifier.js

@@ -93,11 +93,27 @@ function resolveToJSON(node, max) {
 // bound exists to prevent, reached through the bound (proof#71 review). Copying
 // what was measured is what makes check and use the same value. It also settles
 // a getter, which is read once here and never re-read.
+//
+// Every object copy has a NULL prototype, and that is load-bearing too. RFC
+// 8785 has no reserved member names, and `JSON.parse` keeps `__proto__` as an
+// ordinary own key. On a plain `{}`, `copy["__proto__"] = x` runs the setter
+// inherited from `Object.prototype`: it replaces the copy's prototype and
+// creates no key, so the member and everything under it vanished from the
+// canonical bytes. Content there was covered by no hash and no signature, and
+// this kernel disagreed with the Python and Go kernels on the same bytes
+// (0.9.0; the same bug class as proof#31 and proof#34). With no prototype
+// there is no setter, so every key, `__proto__` included, lands as an own data
+// property. `canonicalize` reads the copy with `Object.keys` and `object[key]`
+// and tests `toJSON instanceof Function`, none of which a prototype affects
+// for JSON data, so no other input's output changes.
+function emptyObject() {
+    return Object.create(null);
+}
 function boundedInput(value, max) {
     const root = resolveToJSON(value, max);
     if (root === OVER_DEEP || root === null || typeof root !== "object")
         return root;
-    const copy = Array.isArray(root) ? [] : {};
+    const copy = Array.isArray(root) ? [] : emptyObject();
     const stack = [[root, copy, 1]];
     while (stack.length > 0) {
         const [src, dst, depth] = stack.pop();
@@ -113,7 +129,7 @@ function boundedInput(value, max) {
             }
             if (depth + 1 > max)
                 return OVER_DEEP; // a container nested past the bound
-            const childCopy = Array.isArray(child) ? [] : {};
+            const childCopy = Array.isArray(child) ? [] : emptyObject();
             dst[key] = childCopy;
             stack.push([child, childCopy, depth + 1]);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanning/proof",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "description": "TypeScript kernel of the Sanning verification stack: RFC 8785 (JCS) canonicalization, SHA-256, and Ed25519 verification for Verifiable Event Envelopes. Full-family verifier (inline + external commitment); accepts sanning.agent/v1, sanning.mlflow/v1, sanning.events/v1. Conformance-gated byte-for-byte against the test-vectors corpus.",
   "license": "MIT",
   "type": "module",

package/src/verifier.ts

@@ -103,10 +103,27 @@ function resolveToJSON(node: unknown, max: number): unknown {
 // bound exists to prevent, reached through the bound (proof#71 review). Copying
 // what was measured is what makes check and use the same value. It also settles
 // a getter, which is read once here and never re-read.
+//
+// Every object copy has a NULL prototype, and that is load-bearing too. RFC
+// 8785 has no reserved member names, and `JSON.parse` keeps `__proto__` as an
+// ordinary own key. On a plain `{}`, `copy["__proto__"] = x` runs the setter
+// inherited from `Object.prototype`: it replaces the copy's prototype and
+// creates no key, so the member and everything under it vanished from the
+// canonical bytes. Content there was covered by no hash and no signature, and
+// this kernel disagreed with the Python and Go kernels on the same bytes
+// (0.9.0; the same bug class as proof#31 and proof#34). With no prototype
+// there is no setter, so every key, `__proto__` included, lands as an own data
+// property. `canonicalize` reads the copy with `Object.keys` and `object[key]`
+// and tests `toJSON instanceof Function`, none of which a prototype affects
+// for JSON data, so no other input's output changes.
+function emptyObject(): Record<string, unknown> {
+  return Object.create(null) as Record<string, unknown>;
+}
+
 function boundedInput(value: unknown, max: number): unknown {
   const root = resolveToJSON(value, max);
   if (root === OVER_DEEP || root === null || typeof root !== "object") return root;
-  const copy: Record<string, unknown> | unknown[] = Array.isArray(root) ? [] : {};
+  const copy: Record<string, unknown> | unknown[] = Array.isArray(root) ? [] : emptyObject();
   const stack: Array<[object, Record<string, unknown> | unknown[], number]> = [[root, copy, 1]];
   while (stack.length > 0) {
     const [src, dst, depth] = stack.pop()!;
@@ -120,7 +137,7 @@ function boundedInput(value: unknown, max: number): unknown {
         continue;
       }
       if (depth + 1 > max) return OVER_DEEP; // a container nested past the bound
-      const childCopy: Record<string, unknown> | unknown[] = Array.isArray(child) ? [] : {};
+      const childCopy: Record<string, unknown> | unknown[] = Array.isArray(child) ? [] : emptyObject();
       (dst as Record<string, unknown>)[key] = childCopy;
       stack.push([child, childCopy, depth + 1]);
     }