@bsv/sdk 1.9.16 → 1.9.18

package/docs/reference/primitives.md

@@ -6099,25 +6099,31 @@ toUTF8 = (arr: number[]): string => {
         }
         if (byte <= 127) {
             result += String.fromCharCode(byte);
+            continue;
         }
-        else if (byte >= 192 && byte <= 223) {
-            const byte2 = arr[i + 1];
-            skip = 1;
+        if (byte >= 192 && byte <= 223) {
+            const avail = arr.length - (i + 1);
+            const byte2 = avail >= 1 ? arr[i + 1] : 0;
+            skip = Math.min(1, avail);
             const codePoint = ((byte & 31) << 6) | (byte2 & 63);
             result += String.fromCharCode(codePoint);
+            continue;
         }
-        else if (byte >= 224 && byte <= 239) {
-            const byte2 = arr[i + 1];
-            const byte3 = arr[i + 2];
-            skip = 2;
+        if (byte >= 224 && byte <= 239) {
+            const avail = arr.length - (i + 1);
+            const byte2 = avail >= 1 ? arr[i + 1] : 0;
+            const byte3 = avail >= 2 ? arr[i + 2] : 0;
+            skip = Math.min(2, avail);
             const codePoint = ((byte & 15) << 12) | ((byte2 & 63) << 6) | (byte3 & 63);
             result += String.fromCharCode(codePoint);
+            continue;
         }
-        else if (byte >= 240 && byte <= 247) {
-            const byte2 = arr[i + 1];
-            const byte3 = arr[i + 2];
-            const byte4 = arr[i + 3];
-            skip = 3;
+        if (byte >= 240 && byte <= 247) {
+            const avail = arr.length - (i + 1);
+            const byte2 = avail >= 1 ? arr[i + 1] : 0;
+            const byte3 = avail >= 2 ? arr[i + 2] : 0;
+            const byte4 = avail >= 3 ? arr[i + 3] : 0;
+            skip = Math.min(3, avail);
             const codePoint = ((byte & 7) << 18) |
                 ((byte2 & 63) << 12) |
                 ((byte3 & 63) << 6) |
@@ -6125,6 +6131,7 @@ toUTF8 = (arr: number[]): string => {
             const surrogate1 = 55296 + ((codePoint - 65536) >> 10);
             const surrogate2 = 56320 + ((codePoint - 65536) & 1023);
             result += String.fromCharCode(surrogate1, surrogate2);
+            continue;
         }
     }
     return result;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bsv/sdk",
-  "version": "1.9.16",
+  "version": "1.9.18",
   "type": "module",
   "description": "BSV Blockchain Software Development Kit",
   "main": "dist/cjs/mod.js",

package/src/primitives/Hash.ts

@@ -168,48 +168,42 @@ abstract class BaseHash {
    * @returns Returns an array denoting the padding.
    */
   private _pad (): number[] {
-    //
-    let len = this.pendingTotal
+    const len = this.pendingTotal
     const bytes = this._delta8
     const k = bytes - ((len + this.padLength) % bytes)
     const res = new Array(k + this.padLength)
     res[0] = 0x80
-    let i
+    let i: number
     for (i = 1; i < k; i++) {
       res[i] = 0
     }
 
     // Append length
-    len <<= 3
-    let t
+    const lengthBytes = this.padLength
+    const maxBits = 1n << BigInt(lengthBytes * 8)
+    let totalBits = BigInt(len) * 8n
+
+    if (totalBits >= maxBits) {
+      throw new Error('Message too long for this hash function')
+    }
+
     if (this.endian === 'big') {
-      for (t = 8; t < this.padLength; t++) {
-        res[i++] = 0
+      const lenArray = new Array<number>(lengthBytes)
+
+      for (let b = lengthBytes - 1; b >= 0; b--) {
+        lenArray[b] = Number(totalBits & 0xffn)
+        totalBits >>= 8n
       }
 
-      res[i++] = 0
-      res[i++] = 0
-      res[i++] = 0
-      res[i++] = 0
-      res[i++] = (len >>> 24) & 0xff
-      res[i++] = (len >>> 16) & 0xff
-      res[i++] = (len >>> 8) & 0xff
-      res[i++] = len & 0xff
+      for (let b = 0; b < lengthBytes; b++) {
+        res[i++] = lenArray[b]
+      }
     } else {
-      res[i++] = len & 0xff
-      res[i++] = (len >>> 8) & 0xff
-      res[i++] = (len >>> 16) & 0xff
-      res[i++] = (len >>> 24) & 0xff
-      res[i++] = 0
-      res[i++] = 0
-      res[i++] = 0
-      res[i++] = 0
-
-      for (t = 8; t < this.padLength; t++) {
-        res[i++] = 0
+      for (let b = 0; b < lengthBytes; b++) {
+        res[i++] = Number(totalBits & 0xffn)
+        totalBits >>= 8n
       }
     }
-
     return res
   }
 }

package/src/primitives/__tests/Hash.test.ts

@@ -101,6 +101,54 @@ describe('Hash', function () {
     )
   })
 
+  describe('BaseHash padding and endianness', () => {
+    it('encodes length in big-endian for SHA1', () => {
+      const sha1 = new (hash as any).SHA1()
+      ;(sha1 as any).pendingTotal = 12345
+      const pad = (sha1 as any)._pad() as number[]
+      const padLength = (sha1 as any).padLength as number
+      const lengthBytes = pad.slice(-padLength)
+
+      const totalBits = BigInt(12345) * 8n
+      const expected = new Array<number>(padLength)
+      let tmp = totalBits
+      for (let i = padLength - 1; i >= 0; i--) {
+        expected[i] = Number(tmp & 0xffn)
+        tmp >>= 8n
+      }
+
+      expect(lengthBytes).toEqual(expected)
+    })
+
+    it('encodes length in little-endian for RIPEMD160', () => {
+      const ripemd = new (hash as any).RIPEMD160()
+      ;(ripemd as any).pendingTotal = 12345
+      const pad = (ripemd as any)._pad() as number[]
+      const padLength = (ripemd as any).padLength as number
+      const lengthBytes = pad.slice(-padLength)
+
+      const totalBits = BigInt(12345) * 8n
+      const expected = new Array<number>(padLength)
+      let tmp = totalBits
+      for (let i = 0; i < padLength; i++) {
+        expected[i] = Number(tmp & 0xffn)
+        tmp >>= 8n
+      }
+
+      expect(lengthBytes).toEqual(expected)
+    })
+
+    it('throws when message length exceeds maximum encodable bits', () => {
+      const sha1 = new (hash as any).SHA1()
+      ;(sha1 as any).padLength = 1
+      ;(sha1 as any).pendingTotal = 40
+
+      expect(() => {
+        ;(sha1 as any)._pad()
+      }).toThrow(new Error('Message too long for this hash function'))
+    })
+  })
+
   describe('PBKDF2 vectors', () => {
     for (let i = 0; i < PBKDF2Vectors.length; i++) {
       const v = PBKDF2Vectors[i]

package/src/primitives/__tests/utils.test.ts

@@ -4,6 +4,7 @@ import {
   zero2,
   toHex,
   encode,
+  toUTF8,
   fromBase58,
   toBase58,
   fromBase58Check,
@@ -209,6 +210,48 @@ describe('utils', () => {
   })
 })
 
+describe('toUTF8 bounds checks', () => {
+  const guarded = (arr: number[]): number[] => {
+    const target = arr.slice()
+    const handler: ProxyHandler<number[]> = {
+      get (t, prop, receiver) {
+        if (prop === 'length' || typeof prop !== 'string') {
+          return Reflect.get(t, prop as any, receiver)
+        }
+        const idx = Number(prop)
+        if (Number.isInteger(idx)) {
+          if (idx < 0 || idx >= t.length) {
+            throw new Error(`out-of-bounds read at index ${idx} (length ${t.length})`)
+          }
+        }
+        return Reflect.get(t, prop as any, receiver)
+      }
+    }
+    return new Proxy(target, handler) as unknown as number[]
+  }
+
+  it('does not access out-of-bounds on truncated 2-byte sequence', () => {
+    const input = guarded([0xC3])
+    expect(() => toUTF8(input)).not.toThrow()
+  })
+
+  it('does not access out-of-bounds on truncated 3-byte sequences', () => {
+    const input1 = guarded([0xE2])
+    const input2 = guarded([0xE2, 0x82])
+    expect(() => toUTF8(input1)).not.toThrow()
+    expect(() => toUTF8(input2)).not.toThrow()
+  })
+
+  it('does not access out-of-bounds on truncated 4-byte sequences', () => {
+    const input1 = guarded([0xF0])
+    const input2 = guarded([0xF0, 0x9F])
+    const input3 = guarded([0xF0, 0x9F, 0x98])
+    expect(() => toUTF8(input1)).not.toThrow()
+    expect(() => toUTF8(input2)).not.toThrow()
+    expect(() => toUTF8(input3)).not.toThrow()
+  })
+})
+
 describe('toArray base64', () => {
   it('decodes empty string to empty array', () => {
     expect(toArray('', 'base64')).toEqual([])

package/src/primitives/utils.ts

@@ -237,7 +237,6 @@ export const toUTF8 = (arr: number[]): string => {
 
   for (let i = 0; i < arr.length; i++) {
     const byte = arr[i]
-
     // this byte is part of a multi-byte sequence, skip it
     // added to avoid modifying i within the loop which is considered unsafe.
     if (skip > 0) {
@@ -248,26 +247,41 @@ export const toUTF8 = (arr: number[]): string => {
     // 1-byte sequence (0xxxxxxx)
     if (byte <= 0x7f) {
       result += String.fromCharCode(byte)
-    } else if (byte >= 0xc0 && byte <= 0xdf) {
-      // 2-byte sequence (110xxxxx 10xxxxxx)
-      const byte2 = arr[i + 1]
-      skip = 1
+      continue
+    }
+
+    // 2-byte sequence (110xxxxx 10xxxxxx)
+    if (byte >= 0xc0 && byte <= 0xdf) {
+      const avail = arr.length - (i + 1)
+      const byte2 = avail >= 1 ? arr[i + 1] : 0
+      skip = Math.min(1, avail)
+
       const codePoint = ((byte & 0x1f) << 6) | (byte2 & 0x3f)
       result += String.fromCharCode(codePoint)
-    } else if (byte >= 0xe0 && byte <= 0xef) {
-      // 3-byte sequence (1110xxxx 10xxxxxx 10xxxxxx)
-      const byte2 = arr[i + 1]
-      const byte3 = arr[i + 2]
-      skip = 2
+      continue
+    }
+
+    // 3-byte sequence (1110xxxx 10xxxxxx 10xxxxxx)
+    if (byte >= 0xe0 && byte <= 0xef) {
+      const avail = arr.length - (i + 1)
+      const byte2 = avail >= 1 ? arr[i + 1] : 0
+      const byte3 = avail >= 2 ? arr[i + 2] : 0
+      skip = Math.min(2, avail)
+
       const codePoint =
         ((byte & 0x0f) << 12) | ((byte2 & 0x3f) << 6) | (byte3 & 0x3f)
       result += String.fromCharCode(codePoint)
-    } else if (byte >= 0xf0 && byte <= 0xf7) {
-      // 4-byte sequence (11110xxx 10xxxxxx 10xxxxxx 10xxxxxx)
-      const byte2 = arr[i + 1]
-      const byte3 = arr[i + 2]
-      const byte4 = arr[i + 3]
-      skip = 3
+      continue
+    }
+
+    // 4-byte sequence (11110xxx 10xxxxxx 10xxxxxx 10xxxxxx)
+    if (byte >= 0xf0 && byte <= 0xf7) {
+      const avail = arr.length - (i + 1)
+      const byte2 = avail >= 1 ? arr[i + 1] : 0
+      const byte3 = avail >= 2 ? arr[i + 2] : 0
+      const byte4 = avail >= 3 ? arr[i + 3] : 0
+      skip = Math.min(3, avail)
+
       const codePoint =
         ((byte & 0x07) << 18) |
         ((byte2 & 0x3f) << 12) |
@@ -278,6 +292,7 @@ export const toUTF8 = (arr: number[]): string => {
       const surrogate1 = 0xd800 + ((codePoint - 0x10000) >> 10)
       const surrogate2 = 0xdc00 + ((codePoint - 0x10000) & 0x3ff)
       result += String.fromCharCode(surrogate1, surrogate2)
+      continue
     }
   }