hd-wallet-wasm 2.1.1 → 2.1.2

package/dist/runtime/input-validation.mjs

@@ -45,6 +45,73 @@ export const VALIDATION_ERROR = Object.freeze({
   INVALID_SIGNATURE: 402,
 });
 
+// The length a typed array really has, read from its internal slot through
+// %TypedArray%.prototype's getter: a subclass getter or an own `length`
+// property cannot change it. Captured at load.
+const TYPED_ARRAY_PROTOTYPE = Object.getPrototypeOf(Uint8Array.prototype);
+const TYPED_ARRAY_LENGTH = Object.getOwnPropertyDescriptor(TYPED_ARRAY_PROTOTYPE, 'length').get;
+const TYPED_ARRAY_BUFFER = Object.getOwnPropertyDescriptor(TYPED_ARRAY_PROTOTYPE, 'buffer').get;
+const BUFFER_RESIZABLE = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, 'resizable')?.get;
+const BUFFER_DETACHED = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, 'detached')?.get;
+const SHARED_BUFFER_GROWABLE = typeof SharedArrayBuffer === 'function'
+  ? Object.getOwnPropertyDescriptor(SharedArrayBuffer.prototype, 'growable')?.get
+  : undefined;
+
+/** The internal length of a typed array, or undefined for anything else. */
+function intrinsicLength(value) {
+  try {
+    return TYPED_ARRAY_LENGTH.call(value);
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Whether reading `value.length` reaches %TypedArray%.prototype's getter: no
+ * own `length` property and none on a subclass prototype, so no later read
+ * can answer differently from the check.
+ */
+function hasIntrinsicLengthProperty(value) {
+  for (let object = value; object !== null && object !== TYPED_ARRAY_PROTOTYPE;
+    object = Object.getPrototypeOf(object)) {
+    if (Object.prototype.hasOwnProperty.call(object, 'length')) return false;
+  }
+  return true;
+}
+
+/** Whether a typed array's buffer is detached (transferred). */
+function isDetached(value) {
+  const buffer = TYPED_ARRAY_BUFFER.call(value);
+  if (BUFFER_DETACHED) {
+    try {
+      return BUFFER_DETACHED.call(buffer);
+    } catch {
+      return false;  // A SharedArrayBuffer cannot be detached.
+    }
+  }
+  if (TYPED_ARRAY_LENGTH.call(value) !== 0) return false;
+  try {
+    new Uint8Array(value);
+    return false;
+  } catch {
+    return true;
+  }
+}
+
+/** Whether a typed array's buffer can never change size (not resizable or growable). */
+function hasFixedSize(value) {
+  const buffer = TYPED_ARRAY_BUFFER.call(value);
+  for (const getter of [BUFFER_RESIZABLE, SHARED_BUFFER_GROWABLE]) {
+    if (!getter) continue;
+    try {
+      if (getter.call(buffer)) return false;
+    } catch {
+      // Not that kind of buffer.
+    }
+  }
+  return true;
+}
+
 const CURVE_NAMES = Object.freeze(['secp256k1', 'ed25519', 'P-256', 'P-384', 'X25519']);
 const PRIVATE_KEY_LENGTH = Object.freeze([32, 32, 32, 48, 32]);
 const PUBLIC_KEY_LENGTHS = Object.freeze([
@@ -78,14 +145,39 @@ export function createInputValidation(makeError) {
     return typeof lengths === 'number' ? `${lengths}` : lengths.join(' or ');
   }
 
-  /** True when `value` is a Uint8Array (Node Buffers included). */
+  /**
+   * True when `value` is a Uint8Array (Node Buffers included) whose `length`
+   * is its own (no subclass getter or own property can answer, then or later)
+   * over a buffer that is attached and cannot be resized. A DataView, an
+   * ArrayBuffer or another typed array is not binary data here.
+   */
   function isBytes(value) {
-    return value instanceof Uint8Array;
+    if (intrinsicLength(value) === undefined || !(value instanceof Uint8Array)) return false;
+    return hasIntrinsicLengthProperty(value) && !isDetached(value) && hasFixedSize(value);
+  }
+
+  /**
+   * Binary data checked as by bytes(), returned as a copy made once from the
+   * array's own bytes: later reads of the caller's array cannot change it.
+   */
+  function snapshot(value, name = 'data', code = INVALID_ARGUMENT) {
+    bytes(value, name, code);
+    return new Uint8Array(value);
+  }
+
+  /**
+   * The byte length of binary data from the array itself, never from its
+   * `length` property. Throws for anything isBytes refuses.
+   */
+  function byteLength(value, name = 'data', code = INVALID_ARGUMENT) {
+    bytes(value, name, code);
+    return intrinsicLength(value);
   }
 
   /** True when the length of `bytes` is `lengths` (a number) or one of `lengths`. */
   function hasLength(bytes, lengths) {
-    return typeof lengths === 'number' ? bytes.length === lengths : lengths.includes(bytes.length);
+    const length = intrinsicLength(bytes);
+    return typeof lengths === 'number' ? length === lengths : lengths.includes(length);
   }
 
   /** Require binary data (a Uint8Array) of any length. */
@@ -104,7 +196,8 @@ export function createInputValidation(makeError) {
   /** Require a Uint8Array of min..max bytes. */
   function bytesInRange(value, min, max, name = 'data', code = INVALID_ARGUMENT) {
     bytes(value, name, code);
-    if (value.length < min || value.length > max) {
+    const length = intrinsicLength(value);
+    if (length < min || length > max) {
       fail(code, `${name} must be ${min}-${max} bytes`);
     }
     return value;
@@ -200,13 +293,17 @@ export function createInputValidation(makeError) {
     if (typeof check !== 'function') {
       fail(NOT_SUPPORTED, `Function ${exportName} is not available in this build`);
     }
-    const pointer = wasm._hd_alloc(Math.max(1, value.length));
+    const copy = new Uint8Array(value);
+    const pointer = wasm._hd_alloc(Math.max(1, copy.length));
     if (!pointer) fail(OUT_OF_MEMORY, 'Out of memory');
     try {
-      wasm.HEAPU8.set(value, pointer);
-      return check(pointer, value.length, curveId) === 0;
+      wasm.HEAPU8.set(copy, pointer);
+      return check(pointer, copy.length, curveId) === 0;
     } finally {
-      if (secret) wasm._hd_secure_wipe(pointer, Math.max(1, value.length));
+      if (secret) {
+        wasm._hd_secure_wipe(pointer, Math.max(1, copy.length));
+        copy.fill(0);
+      }
       wasm._hd_dealloc(pointer);
     }
   }
@@ -248,6 +345,8 @@ export function createInputValidation(makeError) {
 
   return Object.freeze({
     isBytes,
+    byteLength,
+    snapshot,
     hasLength,
     bytes,
     bytesOfLength,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hd-wallet-wasm",
-  "version": "2.1.1",
+  "version": "2.1.2",
   "description": "Comprehensive HD Wallet implementation in WebAssembly - BIP-32/39/44, multi-curve, multi-chain support",
   "type": "module",
   "main": "./dist/runtime/index.mjs",
@@ -92,5 +92,5 @@
   "devDependencies": {
     "@types/node": "^20.0.0"
   },
-  "gitHead": "dc864f30a8d277735d73028a38cb4f30e54709a6"
+  "gitHead": "e862d42fcf505cdbc7e928d676bc1a180a167989"
 }