cbor-x 1.6.5 → 1.6.7

package/dist/node.cjs

@@ -21,7 +21,11 @@ const STOP_CODE = {};
 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,
-// many keys in an object, so also probably a reasonable choice there.
+// 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 strings = EMPTY_ARRAY;
 let stringPosition = 0;
 let currentDecoder = {};
@@ -124,7 +128,13 @@ class Decoder {
 			// 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;
@@ -201,15 +211,13 @@ class Decoder {
 		}
 	}
 }
+const nestedDecodeErrors = new WeakSet();
 function checkedRead() {
 	try {
 		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;
@@ -233,20 +241,36 @@ function checkedRead() {
 		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
 	}
 }
 
+function endOfCBORError() {
+	let error = new Error('Unexpected end of CBOR data');
+	error.incomplete = true;
+	return error
+}
+
 function read() {
+	// compared as < so that a NaN position (from a corrupt length) also throws instead of reading undefined
+	if (!(position$1 < srcEnd)) throw endOfCBORError()
 	let token = src[position$1++];
 	let majorType = token >> 5;
 	token = token & 0x1f;
 	if (token > 0x17) {
 		switch (token) {
 			case 0x18:
+				if (position$1 >= srcEnd) throw endOfCBORError()
 				token = src[position$1++];
 				break
 			case 0x19:
@@ -309,13 +333,13 @@ function read() {
 							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();
 								}
 							}
@@ -361,11 +385,13 @@ function read() {
 		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);
@@ -374,15 +400,19 @@ function read() {
 			}
 			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()
 			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 (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();
@@ -392,6 +422,8 @@ function read() {
 					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());
@@ -473,11 +505,7 @@ function read() {
 					throw new Error('Unknown token ' + token)
 			}
 		default: // negative int
-			if (isNaN(token)) {
-				let error = new Error('Unexpected end of CBOR data');
-				error.incomplete = true;
-				throw error
-			}
+			if (isNaN(token)) throw endOfCBORError()
 			throw new Error('Unknown CBOR token ' + token)
 	}
 }
@@ -926,18 +954,12 @@ currentExtensions[27] = (data) => { // http://cbor.schmorp.de/generic-object
 	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();
@@ -955,10 +977,7 @@ currentExtensions[PACKED_REFERENCE_TAG_ID] = (data) => { // packed reference
 	}
 	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
@@ -1028,9 +1047,19 @@ currentExtensions[258] = (array) => new Set(array); // https://github.com/input-
 (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;
@@ -1141,17 +1170,21 @@ function readBundleExt() {
 }
 
 function readJustLength() {
+	if (!(position$1 < srcEnd)) throw endOfCBORError()
 	let token = src[position$1++] & 0x1f;
 	if (token > 0x17) {
 		switch (token) {
 			case 0x18:
+				if (position$1 >= srcEnd) throw endOfCBORError()
 				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
@@ -1193,22 +1226,27 @@ function saveState(callback) {
 	let savedStructures = currentStructures;
 	let savedDecoder = currentDecoder;
 	let savedSequentialMode = sequentialMode;
-	let value = callback();
-	srcEnd = savedSrcEnd;
-	position$1 = savedPosition;
-	stringPosition = savedStringPosition;
-	srcStringStart = savedSrcStringStart;
-	srcStringEnd = savedSrcStringEnd;
-	srcString = savedSrcString;
-	strings = savedStrings;
-	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;
+	restoreMapsAsObject = false;
+	try {
+		return callback()
+	} finally {
+		srcEnd = savedSrcEnd;
+		position$1 = savedPosition;
+		stringPosition = savedStringPosition;
+		srcStringStart = savedSrcStringStart;
+		srcStringEnd = savedSrcStringEnd;
+		srcString = savedSrcString;
+		strings = savedStrings;
+		referenceMap = savedReferenceMap;
+		bundledStrings$1 = savedBundledStrings;
+		src = savedSrc;
+		sequentialMode = savedSequentialMode;
+		currentStructures = savedStructures;
+		currentDecoder = savedDecoder;
+		restoreMapsAsObject = savedRestoreMapsAsObject;
+		dataView = new DataView(src.buffer, src.byteOffset, src.byteLength);
+	}
 }
 function clearSource() {
 	src = null;
@@ -1223,7 +1261,8 @@ function addExtension$1(extension) {
 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
@@ -1425,7 +1464,7 @@ class Encoder extends Decoder {
 				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
@@ -2510,24 +2549,22 @@ class DecoderStream extends stream.Transform {
 			chunk = Buffer.concat([this.incompleteBuffer, chunk]);
 			this.incompleteBuffer = null;
 		}
-		let values;
+		let values, fatalError;
 		try {
 			values = this.decoder.decodeMultiple(chunk);
 		} catch(error) {
-			if (error.incomplete) {
+			values = error.values;
+			if (error.incomplete)
 				this.incompleteBuffer = chunk.slice(error.lastPosition);
-				values = error.values;
-			} else {
-				return callback(error)
-			}
-		} finally {
-			for (let value of values || []) {
-				if (value === null)
-					value = this.getNullValue();
-				this.push(value);
-			}
+			else
+				fatalError = error;
+		}
+		for (let value of values || []) {
+			if (value === null)
+				value = this.getNullValue();
+			this.push(value);
 		}
-		callback();
+		callback(fatalError);
 	}
 	getNullValue() {
 		return Symbol.for(null)
@@ -2580,7 +2617,7 @@ function decodeIter (bufferIterator, options = {}) {
   }
 
   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
@@ -2592,26 +2629,28 @@ function decodeIter (bufferIterator, options = {}) {
     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
       }
     })()
   }