cbor-x 1.6.6 → 1.6.8

package/dist/index.js

@@ -20,6 +20,11 @@
 	let maxArraySize = 112810000; // This is the maximum array size in V8. We would potentially detect and set it higher
 	// for JSC, but this is pretty large and should be sufficient for most use cases
 	let maxMapSize = 16810000; // JavaScript has a fixed maximum map size of about 16710000, but JS itself enforces this,
+	// so we don't need to
+
+	let maxObjectSize = 16710000; // It takes over a minute to create this many keys in an object, so this is probably a
+	// reasonable choice.
+	let objectSizeLimit = maxObjectSize; // objects are limited by both maxObjectSize and maxMapSize
 	let currentDecoder = {};
 	let currentStructures;
 	let srcString;
@@ -120,7 +125,13 @@
 				// re-entrant execution, save the state and restore it after we do this decode
 				return saveState(() => {
 					clearSource();
-					return this ? this.decode(source, end) : Decoder.prototype.decode.call(defaultOptions, source, end)
+					try {
+						return this ? this.decode(source, end) : Decoder.prototype.decode.call(defaultOptions, source, end)
+					} catch (error) {
+						if (error && typeof error == 'object')
+							nestedDecodeErrors.add(error);
+						throw error
+					}
 				})
 			}
 			srcEnd = end > -1 ? end : source.length;
@@ -195,15 +206,15 @@
 			}
 		}
 	}
+	const nestedDecodeErrors = new WeakSet();
+	let arrayAllocationBudget;
 	function checkedRead() {
 		try {
+			arrayAllocationBudget = srcEnd - position$1;
 			let result = read();
 			if (bundledStrings$1) {
-				if (position$1 >= bundledStrings$1.postBundlePosition) {
-					let error = new Error('Unexpected bundle position');
-					error.incomplete = true;
-					throw error
-				}
+				if (position$1 >= bundledStrings$1.postBundlePosition)
+					throw new Error('Unexpected bundle position')
 				// bundled strings to skip past
 				position$1 = bundledStrings$1.postBundlePosition;
 				bundledStrings$1 = null;
@@ -227,7 +238,14 @@
 			return result
 		} catch(error) {
 			clearSource();
-			if (error instanceof RangeError || error.message.startsWith('Unexpected end of buffer')) {
+			if (nestedDecodeErrors.has(error)) {
+				// from a nested decode of embedded data (by an extension), which was complete in this source
+				if (error.incomplete)
+					error.incomplete = false;
+			} else if (error instanceof RangeError && position$1 + 8 > srcEnd ||
+					error && typeof error.message == 'string' && error.message.startsWith('Unexpected end of buffer')) {
+				// a DataView read past the end of the source; these read at most 8 bytes and precede advancing position.
+				// Any other RangeError (such as a stack overflow from deeply nested input) is fatal.
 				error.incomplete = true;
 			}
 			throw error
@@ -312,13 +330,13 @@
 								let i = 0;
 								if (currentDecoder.keyMap) {
 									while((key = read()) != STOP_CODE) {
-										if (i++ >= maxMapSize) throw new Error(`Property count exceeds ${maxMapSize}`)
+										if (i++ >= objectSizeLimit) throw new Error(`Property count exceeds ${objectSizeLimit}`)
 										object[safeKey(currentDecoder.decodeKey(key))] = read();
 									}
 								}
 								else {
 									while ((key = read()) != STOP_CODE) {
-										if (i++ >= maxMapSize) throw new Error(`Property count exceeds ${maxMapSize}`)
+										if (i++ >= objectSizeLimit) throw new Error(`Property count exceeds ${objectSizeLimit}`)
 										object[safeKey(key)] = read();
 									}
 								}
@@ -364,11 +382,13 @@
 			case 1: // negative int
 				return ~token
 			case 2: // buffer
+				if (token > srcEnd - position$1) throw endOfCBORError()
 				return readBin(token)
 			case 3: // string
-				if (srcStringEnd >= position$1) {
+				if (srcStringEnd >= position$1) { // already extracted, which only covers complete strings
 					return srcString.slice(position$1 - srcStringStart, (position$1 += token) - srcStringStart)
 				}
+				if (token > srcEnd - position$1) throw endOfCBORError()
 				if (srcStringEnd == 0 && srcEnd < 140 && token < 32) {
 					// for small blocks, avoiding the overhead of the extract call is helpful
 					let string = token < 16 ? shortStringInJS(token) : longStringInJS(token);
@@ -377,19 +397,21 @@
 				}
 				return readFixedString(token)
 			case 4: // array
-				if (token >= maxArraySize) throw new Error(`Array length exceeds ${maxArraySize}`)
+				if (token > maxArraySize) throw new Error(`Array length exceeds ${maxArraySize}`)
 				// every element occupies at least one byte, so a length beyond what remains in the source can
 				// never be satisfied; check before allocating so a tiny header can not force a huge allocation
-				if (token > srcEnd - position$1) throw endOfCBORError()
+				// nested arrays each pass the check above yet still preallocate, so also spend from a
+				// per-decode budget of the remaining bytes; the summed lengths of any valid tree stay under it
+				if (token > srcEnd - position$1 || (arrayAllocationBudget -= token) < 0) throw endOfCBORError()
 				let array = new Array(token);
 			  //if (currentDecoder.keyMap) for (let i = 0; i < token; i++) array[i] = currentDecoder.decodeKey(read())	
 				//else 
 				for (let i = 0; i < token; i++) array[i] = read();
 				return array
 			case 5: // map
-				if (token >= maxMapSize) throw new Error(`Map size exceeds ${maxArraySize}`)
-				if (token > (srcEnd - position$1) / 2) throw endOfCBORError() // each entry needs at least two bytes
 				if (currentDecoder.mapsAsObjects) {
+					if (token > objectSizeLimit) throw new Error(`Property count exceeds ${objectSizeLimit}`)
+					if (token > (srcEnd - position$1) / 2) throw endOfCBORError() // each entry needs at least two bytes
 					let object = {};
 					if (currentDecoder.keyMap) for (let i = 0; i < token; i++) object[safeKey(currentDecoder.decodeKey(read()))] = read();
 					else for (let i = 0; i < token; i++) object[safeKey(read())] = read();
@@ -399,6 +421,8 @@
 						currentDecoder.mapsAsObjects = true;
 						restoreMapsAsObject = false;
 					}
+					if (token > maxMapSize) throw new Error(`Map size exceeds ${maxMapSize}`)
+					if (token > (srcEnd - position$1) / 2) throw endOfCBORError()
 					let map = new Map();
 					if (currentDecoder.keyMap) for (let i = 0; i < token; i++) map.set(currentDecoder.decodeKey(read()),read());
 					else for (let i = 0; i < token; i++) map.set(read(), read());
@@ -894,18 +918,12 @@
 		return (glbl[data[0]] || Error)(data[1], data[2])
 	};
 	const packedTable = (read) => {
-		if (src[position$1++] != 0x84) {
-			let error = new Error('Packed values structure must be followed by a 4 element array');
-			if (src.length < position$1)
-				error.incomplete = true;
-			throw error
-		}
+		if (!(position$1 < srcEnd)) throw endOfCBORError()
+		if (src[position$1++] != 0x84)
+			throw new Error('Packed values structure must be followed by a 4 element array')
 		let newPackedValues = read(); // packed values
-		if (!newPackedValues || !newPackedValues.length) {
-			let error = new Error('Packed values structure must be followed by a 4 element array');
-			error.incomplete = true;
-			throw error
-		}
+		if (!Array.isArray(newPackedValues) || !newPackedValues.length)
+			throw new Error('Packed values structure must be followed by a 4 element array')
 		packedValues = packedValues ? newPackedValues.concat(packedValues.slice(newPackedValues.length)) : newPackedValues;
 		packedValues.prefixes = read();
 		packedValues.suffixes = read();
@@ -923,10 +941,7 @@
 		}
 		if (typeof data == 'number')
 			return packedValues[16 + (data >= 0 ? 2 * data : (-2 * data - 1))]
-		let error = new Error('No support for non-integer packed references yet');
-		if (data === undefined)
-			error.incomplete = true;
-		throw error
+		throw new Error('No support for non-integer packed references yet')
 	};
 
 	// The following code is an incomplete implementation of http://cbor.schmorp.de/stringref
@@ -996,9 +1011,19 @@
 	(currentExtensions[259] = (read) => {
 		// https://github.com/shanewholloway/js-cbor-codec/blob/master/docs/CBOR-259-spec
 		// for decoding as a standard Map
-		if (currentDecoder.mapsAsObjects) {
-			currentDecoder.mapsAsObjects = false;
+		let decoder = currentDecoder;
+		if (decoder.mapsAsObjects) {
+			decoder.mapsAsObjects = false;
 			restoreMapsAsObject = true;
+			try {
+				return read()
+			} finally {
+				// normally restored by the map header, but not if the tagged value is not a map or the read fails
+				if (restoreMapsAsObject) {
+					decoder.mapsAsObjects = true;
+					restoreMapsAsObject = false;
+				}
+			}
 		}
 		return read()
 	}).handlesRead = true;
@@ -1118,10 +1143,12 @@
 					token = src[position$1++];
 					break
 				case 0x19:
+					if (position$1 + 2 > srcEnd) throw endOfCBORError()
 					token = dataView.getUint16(position$1);
 					position$1 += 2;
 					break
 				case 0x1a:
+					if (position$1 + 4 > srcEnd) throw endOfCBORError()
 					token = dataView.getUint32(position$1);
 					position$1 += 4;
 					break
@@ -1161,20 +1188,27 @@
 		let savedStructures = currentStructures;
 		let savedDecoder = currentDecoder;
 		let savedSequentialMode = sequentialMode;
-		let value = callback();
-		srcEnd = savedSrcEnd;
-		position$1 = savedPosition;
-		srcStringStart = savedSrcStringStart;
-		srcStringEnd = savedSrcStringEnd;
-		srcString = savedSrcString;
-		referenceMap = savedReferenceMap;
-		bundledStrings$1 = savedBundledStrings;
-		src = savedSrc;
-		sequentialMode = savedSequentialMode;
-		currentStructures = savedStructures;
-		currentDecoder = savedDecoder;
-		dataView = new DataView(src.buffer, src.byteOffset, src.byteLength);
-		return value
+		let savedRestoreMapsAsObject = restoreMapsAsObject;
+		let savedArrayAllocationBudget = arrayAllocationBudget;
+		restoreMapsAsObject = false;
+		try {
+			return callback()
+		} finally {
+			srcEnd = savedSrcEnd;
+			position$1 = savedPosition;
+			srcStringStart = savedSrcStringStart;
+			srcStringEnd = savedSrcStringEnd;
+			srcString = savedSrcString;
+			referenceMap = savedReferenceMap;
+			bundledStrings$1 = savedBundledStrings;
+			src = savedSrc;
+			sequentialMode = savedSequentialMode;
+			currentStructures = savedStructures;
+			currentDecoder = savedDecoder;
+			restoreMapsAsObject = savedRestoreMapsAsObject;
+			arrayAllocationBudget = savedArrayAllocationBudget;
+			dataView = new DataView(src.buffer, src.byteOffset, src.byteLength);
+		}
 	}
 	function clearSource() {
 		src = null;
@@ -1189,7 +1223,8 @@
 	function setSizeLimits(limits) {
 		if (limits.maxMapSize) maxMapSize = limits.maxMapSize;
 		if (limits.maxArraySize) maxArraySize = limits.maxArraySize;
-		if (limits.maxObjectSize) limits.maxObjectSize;
+		if (limits.maxObjectSize) maxObjectSize = limits.maxObjectSize;
+		objectSizeLimit = Math.min(maxObjectSize, maxMapSize);
 	}
 
 	const mult10 = new Array(147); // this is a table matching binary exponents to the multiplier to determine significant digit rounding
@@ -1391,7 +1426,7 @@
 					if (throwOnIterable)
 						return;
 					encode(value);
-					if (bundledStrings) {
+					if (bundledStrings && bundledStrings.position) { // position is only set once a bundle has been started
 						writeBundles(start, encode);
 					}
 					encoder.offset = position; // update the offset so next serialization doesn't write over our buffer, but can continue writing to same buffer sequentially
@@ -2489,7 +2524,7 @@
 	  }
 
 	  const decoder = new Decoder(options);
-	  let incomplete;
+	  let incomplete, fatalError;
 	  const parser = (chunk) => {
 	    let yields;
 	    // if there's incomplete data from previous chunk, concatinate and try again
@@ -2501,26 +2536,28 @@
 	    try {
 	      yields = decoder.decodeMultiple(chunk);
 	    } catch (err) {
+	      yields = err.values;
 	      if (err.incomplete) {
 	        incomplete = chunk.slice(err.lastPosition);
-	        yields = err.values;
 	      } else {
-	        throw err
+	        fatalError = err;
 	      }
 	    }
-	    return yields
+	    return yields || []
 	  };
 
 	  if (typeof bufferIterator[Symbol.iterator] === 'function') {
 	    return (function * iter () {
 	      for (const value of bufferIterator) {
 	        yield * parser(value);
+	        if (fatalError) throw fatalError
 	      }
 	    })()
 	  } else if (typeof bufferIterator[Symbol.asyncIterator] === 'function') {
 	    return (async function * iter () {
 	      for await (const value of bufferIterator) {
 	        yield * parser(value);
+	        if (fatalError) throw fatalError
 	      }
 	    })()
 	  }