@marcuspuchalla/nachos 0.1.3 → 0.1.4

package/src/parser/composables/useCborCollection.ts

@@ -6,7 +6,7 @@
 
 import type { ParseResult, CborValue, CborMap, ParseOptions } from '../types'
 import { INDEFINITE_SYMBOL, ALL_ENTRIES_SYMBOL } from '../types'
-import { hexToBytes, readByte, readUint, readBigUint, extractCborHeader, compareBytes, bytesToHex } from '../utils'
+import { hexToBytes, readByte, readUint, readBigUint, extractCborHeader, compareBytes, serializeValueForComparison } from '../utils'
 import { useCborInteger } from './useCborInteger'
 import { useCborString } from './useCborString'
 import { useCborFloat } from './useCborFloat'
@@ -25,21 +25,13 @@ import { logger } from '../../utils/logger'
  * ```
  */
 export function useCborCollection() {
-  const { parseInteger } = useCborInteger()
+  const { parseIntegerFromBuffer } = useCborInteger()
   const { parseByteString, parseTextString } = useCborString()
-  const { parse: parseFloatOrSimple } = useCborFloat()
-  const { parseTag } = useCborTag()
+  const { parseFromBuffer: parseFloatOrSimpleFromBuffer } = useCborFloat()
+  const { parseTagFromBuffer } = useCborTag()
 
-  /**
-   * Convert a CBOR value to a string key for use in JavaScript objects
-   * Handles Uint8Array keys by converting them to hex strings
-   */
-  const convertKeyToString = (key: CborValue): string => {
-    if (key instanceof Uint8Array) {
-      return bytesToHex(key)
-    }
-    return String(key)
-  }
+  /** Tracks when parsing started for timeout enforcement */
+  let parseStartTime = 0
 
   /**
    * Internal parser dispatcher for CBOR items
@@ -52,6 +44,14 @@ export function useCborCollection() {
    * @returns Parsed value and bytes consumed
    */
   const parseItem = (buffer: Uint8Array, offset: number, options?: ParseOptions, depth: number = 0): ParseResult => {
+    // Check timeout on every recursive call
+    if (parseStartTime > 0 && options?.limits?.maxParseTime) {
+      const elapsed = Date.now() - parseStartTime
+      if (elapsed > options.limits.maxParseTime) {
+        throw new Error(`Parse timeout: exceeded ${options.limits.maxParseTime}ms limit`)
+      }
+    }
+
     if (offset >= buffer.length) {
       throw new Error(`Unexpected end of buffer at offset ${offset}`)
     }
@@ -62,14 +62,7 @@ export function useCborCollection() {
     switch (majorType) {
       case 0: // Unsigned integer
       case 1: // Negative integer
-        {
-          // Create a hex string from the buffer starting at offset
-          const intHex = Array.from(buffer.slice(offset))
-            .map(b => b.toString(16).padStart(2, '0'))
-            .join('')
-          const result = parseInteger(intHex, options)
-          return { value: result.value, bytesRead: result.bytesRead }
-        }
+        return parseIntegerFromBuffer(buffer, offset, options)
 
       case 2: // Byte string
         return parseByteString(buffer, offset, options)
@@ -84,22 +77,10 @@ export function useCborCollection() {
         return parseMapFromBuffer(buffer, offset, options, depth)
 
       case 6: // Tag
-        {
-          const tagHex = Array.from(buffer.slice(offset))
-            .map(b => b.toString(16).padStart(2, '0'))
-            .join('')
-          const result = parseTag(tagHex, options)
-          return { value: result.value, bytesRead: result.bytesRead }
-        }
+        return parseTagFromBuffer(buffer, offset, options)
 
       case 7: // Simple/Float
-        {
-          const floatHex = Array.from(buffer.slice(offset))
-            .map(b => b.toString(16).padStart(2, '0'))
-            .join('')
-          const result = parseFloatOrSimple(floatHex, options)
-          return { value: result.value, bytesRead: result.bytesRead }
-        }
+        return parseFloatOrSimpleFromBuffer(buffer, offset, options)
 
       default:
         throw new Error(`Unknown major type: ${majorType}`)
@@ -356,8 +337,10 @@ export function useCborCollection() {
         const valueResult = parseItem(buffer, currentOffset, options, depth + 1)
         currentOffset += valueResult.bytesRead
 
-        // For duplicate key detection, serialize the key
-        const keyString = convertKeyToString(keyResult.value)
+        // For duplicate key detection, serialize the parsed value semantically
+        // RFC 8949 Section 5.6: comparison must be on semantic values, not raw bytes
+        // (raw bytes differ when same value uses different byte widths)
+        const keyString = serializeValueForComparison(keyResult.value)
 
         // Check for duplicate keys based on dupMapKeyMode
         // RFC 8949: Deterministic encoding SHOULD reject duplicate keys
@@ -420,8 +403,10 @@ export function useCborCollection() {
         const valueResult = parseItem(buffer, currentOffset, options, depth + 1)
         currentOffset += valueResult.bytesRead
 
-        // For duplicate key detection, serialize the key
-        const keyString = convertKeyToString(keyResult.value)
+        // For duplicate key detection, serialize the parsed value semantically
+        // RFC 8949 Section 5.6: comparison must be on semantic values, not raw bytes
+        // (raw bytes differ when same value uses different byte widths)
+        const keyString = serializeValueForComparison(keyResult.value)
 
         // Check for duplicate keys based on dupMapKeyMode
         // RFC 8949: Deterministic encoding SHOULD reject duplicate keys
@@ -485,7 +470,16 @@ export function useCborCollection() {
     // Remove spaces from hex string
     const cleanHex = hexString.replace(/\s+/g, '')
     const buffer = hexToBytes(cleanHex)
-    return parseArrayFromBuffer(buffer, 0, options, 0)
+
+    // Set parse start time for timeout enforcement
+    if (options?.limits?.maxParseTime) {
+      parseStartTime = Date.now()
+    }
+    try {
+      return parseArrayFromBuffer(buffer, 0, options, 0)
+    } finally {
+      parseStartTime = 0
+    }
   }
 
   /**
@@ -499,7 +493,16 @@ export function useCborCollection() {
     // Remove spaces from hex string
     const cleanHex = hexString.replace(/\s+/g, '')
     const buffer = hexToBytes(cleanHex)
-    return parseMapFromBuffer(buffer, 0, options, 0)
+
+    // Set parse start time for timeout enforcement
+    if (options?.limits?.maxParseTime) {
+      parseStartTime = Date.now()
+    }
+    try {
+      return parseMapFromBuffer(buffer, 0, options, 0)
+    } finally {
+      parseStartTime = 0
+    }
   }
 
   return {

package/src/parser/composables/useCborFloat.ts

@@ -336,6 +336,7 @@ export function useCborFloat() {
   return {
     parse,
     parseFloat,
-    parseSimple
+    parseSimple,
+    parseFromBuffer
   }
 }

package/src/parser/composables/useCborInteger.ts

@@ -20,15 +20,15 @@ import { hexToBytes, readByte, readUint, readBigUint, extractCborHeader, validat
  */
 export function useCborInteger() {
   /**
-   * Parses CBOR integer (Major Type 0 or 1)
+   * Parses CBOR integer (Major Type 0 or 1) from a buffer at a given offset
    *
-   * @param hexString - CBOR hex string
+   * @param buffer - Data buffer
+   * @param offset - Current offset into the buffer
    * @param options - Parser options (optional)
    * @returns Parsed integer value and bytes read
    */
-  const parseInteger = (hexString: string, options?: ParseOptions): ParseResult => {
-    const buffer = hexToBytes(hexString)
-    const initialByte = readByte(buffer, 0)
+  const parseIntegerFromBuffer = (buffer: Uint8Array, offset: number, options?: ParseOptions): ParseResult => {
+    const initialByte = readByte(buffer, offset)
 
     const { majorType, additionalInfo } = extractCborHeader(initialByte)
 
@@ -42,19 +42,19 @@ export function useCborInteger() {
       bytesRead = 1
     } else if (additionalInfo === 24) {
       // 1 byte follows
-      rawValue = readByte(buffer, 1)
+      rawValue = readByte(buffer, offset + 1)
       bytesRead = 2
     } else if (additionalInfo === 25) {
       // 2 bytes follow
-      rawValue = readUint(buffer, 1, 2)
+      rawValue = readUint(buffer, offset + 1, 2)
       bytesRead = 3
     } else if (additionalInfo === 26) {
       // 4 bytes follow
-      rawValue = readUint(buffer, 1, 4)
+      rawValue = readUint(buffer, offset + 1, 4)
       bytesRead = 5
     } else if (additionalInfo === 27) {
       // 8 bytes follow - use BigInt for large values
-      const bigValue = readBigUint(buffer, 1, 8)
+      const bigValue = readBigUint(buffer, offset + 1, 8)
 
       // Check if value fits in Number.MAX_SAFE_INTEGER
       if (bigValue <= BigInt(Number.MAX_SAFE_INTEGER)) {
@@ -108,7 +108,21 @@ export function useCborInteger() {
     }
   }
 
+  /**
+   * Parses CBOR integer (Major Type 0 or 1) from hex string
+   * Thin wrapper around parseIntegerFromBuffer
+   *
+   * @param hexString - CBOR hex string
+   * @param options - Parser options (optional)
+   * @returns Parsed integer value and bytes read
+   */
+  const parseInteger = (hexString: string, options?: ParseOptions): ParseResult => {
+    const buffer = hexToBytes(hexString)
+    return parseIntegerFromBuffer(buffer, 0, options)
+  }
+
   return {
-    parseInteger
+    parseInteger,
+    parseIntegerFromBuffer
   }
 }