msgpack5 6.0.1 → 6.1.0

package/test/max-depth.js

@@ -0,0 +1,95 @@
+'use strict'
+
+const Buffer = require('safe-buffer').Buffer
+const test = require('tape').test
+const msgpack = require('../')
+
+function nestedArray (depth) {
+  return Buffer.concat([Buffer.alloc(depth, 0x91), Buffer.from([0xc0])])
+}
+
+function nestedMap (depth) {
+  const prefix = Buffer.alloc(depth * 3)
+
+  for (let i = 0; i < depth; i++) {
+    prefix[i * 3] = 0x81
+    prefix[i * 3 + 1] = 0xa1
+    prefix[i * 3 + 2] = 0x78
+  }
+
+  return Buffer.concat([prefix, Buffer.from([0xc0])])
+}
+
+test('limits array and map nesting depth by default', function (t) {
+  const pack = msgpack()
+  let array = pack.decode(nestedArray(100))
+  let map = pack.decode(nestedMap(100))
+
+  for (let i = 0; i < 100; i++) {
+    array = array[0]
+    map = map.x
+  }
+
+  t.equal(array, null, 'decodes arrays at the limit')
+  t.equal(map, null, 'decodes maps at the limit')
+  t.throws(function () {
+    pack.decode(nestedArray(101))
+  }, /Maximum decode depth exceeded/, 'rejects arrays over the limit')
+  t.throws(function () {
+    pack.decode(nestedMap(101))
+  }, /Maximum decode depth exceeded/, 'rejects maps over the limit')
+  t.end()
+})
+
+test('supports a custom maximum nesting depth', function (t) {
+  const pack = msgpack({ maxDepth: 2 })
+
+  t.doesNotThrow(function () {
+    pack.decode(nestedArray(2))
+  }, 'decodes input at the configured limit')
+  t.throws(function () {
+    pack.decode(nestedArray(3))
+  }, /Maximum decode depth exceeded/, 'rejects input over the configured limit')
+  t.end()
+})
+
+test('defaults maxDepth when other options are provided', function (t) {
+  const pack = msgpack({ forceFloat64: true })
+
+  t.throws(function () {
+    pack.decode(nestedArray(101))
+  }, /Maximum decode depth exceeded/)
+  t.end()
+})
+
+test('allows scalars but no containers when maxDepth is zero', function (t) {
+  const pack = msgpack({ maxDepth: 0 })
+
+  t.equal(pack.decode(Buffer.from([0xc0])), null, 'decodes a scalar')
+  t.throws(function () {
+    pack.decode(Buffer.from([0x90]))
+  }, /Maximum decode depth exceeded/, 'rejects an empty container')
+  t.end()
+})
+
+test('validates maxDepth', function (t) {
+  const invalid = [-1, 1.5, Infinity, NaN, '100', null]
+
+  invalid.forEach(function (maxDepth) {
+    t.throws(function () {
+      msgpack({ maxDepth })
+    }, /maxDepth must be a non-negative integer/)
+  })
+  t.end()
+})
+
+test('reports a controlled error from the decoder stream', function (t) {
+  t.plan(2)
+
+  const decoder = msgpack().decoder()
+  decoder.on('error', function (err) {
+    t.equal(err.message, 'Maximum decode depth exceeded')
+    t.notOk(err instanceof RangeError, 'does not exhaust the native stack')
+  })
+  decoder.end(nestedArray(101))
+})

package/test/object-prototype-poisoning.js

@@ -18,6 +18,52 @@ test('decode throws when object has forbidden __proto__ property', function (t)
   t.end()
 })
 
+test('decode defaults protoAction with partial options', function (t) {
+  const payload = { hello: 'world' }
+  Object.defineProperty(payload, '__proto__', {
+    value: { polluted: true },
+    enumerable: true
+  })
+
+  const encoded = msgpack().encode(payload)
+  const options = [
+    {},
+    { forceFloat64: true },
+    { compatibilityMode: true },
+    { disableTimestampEncoding: true },
+    { preferMap: false },
+    { sortKeys: true },
+    { protoAction: undefined }
+  ]
+
+  options.forEach(function (opts) {
+    t.throws(function () {
+      msgpack(opts).decode(encoded)
+    }, /Object contains forbidden prototype property/)
+  })
+  t.equal({}.polluted, undefined, 'does not affect Object.prototype')
+  t.end()
+})
+
+test('does not mutate the caller options object', function (t) {
+  const options = { forceFloat64: true }
+  msgpack(options)
+
+  t.equal(options.protoAction, undefined)
+  t.end()
+})
+
+test('validates protoAction', function (t) {
+  const invalid = [null, false, '', 'typo']
+
+  invalid.forEach(function (protoAction) {
+    t.throws(function () {
+      msgpack({ protoAction })
+    }, /protoAction must be "error", "remove", or "ignore"/)
+  })
+  t.end()
+})
+
 test('decode ignores forbidden __proto__ property if protoAction is "ignore"', function (t) {
   const encoder = msgpack({ protoAction: 'ignore' })
 
@@ -30,6 +76,9 @@ test('decode ignores forbidden __proto__ property if protoAction is "ignore"', f
   const decoded = encoder.decode(encoder.encode(payload))
 
   t.equal(decoded.polluted, true)
+  t.notEqual(Object.getPrototypeOf(decoded), Object.prototype)
+  t.notOk(Object.prototype.hasOwnProperty.call(decoded, 'polluted'))
+  t.equal({}.polluted, undefined, 'does not affect Object.prototype')
   t.end()
 })
 
@@ -45,5 +94,6 @@ test('decode removes forbidden __proto__ property if protoAction is "remove"', f
   const decoded = encoder.decode(encoder.encode(payload))
 
   t.equal(decoded.polluted, undefined)
+  t.equal(Object.getPrototypeOf(decoded), Object.prototype)
   t.end()
 })

package/test/reserved-byte.js

@@ -0,0 +1,53 @@
+'use strict'
+
+const Buffer = require('safe-buffer').Buffer
+const test = require('tape').test
+const msgpack = require('../')
+
+const reservedByteError = '0xc1 is a reserved MessagePack byte'
+
+test('reserved byte is invalid rather than incomplete', function (t) {
+  t.plan(3)
+
+  const pack = msgpack()
+  let error
+
+  try {
+    pack.decode(Buffer.from([0xc1]))
+  } catch (err) {
+    error = err
+  }
+
+  t.ok(error, 'must throw an error')
+  t.notOk(error instanceof pack.IncompleteBufferError, 'must not report incomplete input')
+  t.equal(error.message, reservedByteError, 'must identify the reserved byte')
+})
+
+test('stream decoder rejects reserved byte without retaining input', function (t) {
+  t.plan(5)
+
+  const decoder = msgpack().decoder()
+  let decoded = 0
+  let errors = 0
+
+  decoder.on('data', function () {
+    decoded++
+  })
+
+  decoder.on('error', function (err) {
+    errors++
+    t.equal(err.message, reservedByteError, 'must emit the decoding error')
+  })
+
+  decoder.on('close', function () {
+    t.equal(decoded, 0, 'must not emit decoded values')
+    t.equal(errors, 1, 'must emit one error')
+    t.equal(decoder._chunks.length, 0, 'must release buffered input')
+    t.ok(decoder.destroyed, 'must stop accepting input')
+  })
+
+  decoder.write(Buffer.concat([
+    Buffer.from([0xc1]),
+    Buffer.alloc(200 * 1024, 0x01)
+  ]))
+})

package/test/streams.js

@@ -183,6 +183,84 @@ test('concatenated buffers work', function (t) {
   encoder.end()
 })
 
+test('map32 header split across chunks', function (t) {
+  t.plan(2)
+
+  const decoder = msgpack().decoder()
+
+  decoder.on('data', function (value) {
+    t.deepEqual(value, {}, 'must decode the map')
+  })
+
+  decoder.on('error', function (err) {
+    t.fail(err.message)
+  })
+
+  decoder.on('end', function () {
+    t.pass('must end normally')
+  })
+
+  const encoded = [0xdf, 0x00, 0x00, 0x00, 0x00]
+  encoded.forEach(function (byte) {
+    decoder.write(Buffer.from([byte]))
+  })
+  decoder.end()
+})
+
+test('many concatenated values do not overflow the stack', function (t) {
+  t.plan(2)
+
+  const total = 50000
+  const decoder = msgpack().decoder()
+  let decoded = 0
+
+  decoder.on('data', function () {
+    decoded++
+  })
+
+  decoder.write(Buffer.alloc(total, 0x01), function (err) {
+    t.error(err, 'must decode without an error')
+    t.equal(decoded, total, 'must decode every value')
+  })
+})
+
+test('incomplete containers resume without decoding elements again', function (t) {
+  t.plan(3)
+
+  const pack = msgpack()
+  const decoder = pack.decoder()
+  const values = []
+  let decodeCalls = 0
+  let maxBuffered = 0
+
+  function MyType (value) {
+    this.value = value
+  }
+
+  pack.register(0x42, MyType, function (obj) {
+    return Buffer.from([obj.value])
+  }, function (buf) {
+    decodeCalls++
+    return buf.readUInt8(0)
+  })
+
+  for (let i = 0; i < 100; i++) {
+    values.push(new MyType(i))
+  }
+
+  decoder.on('data', function (result) {
+    t.deepEqual(result, { values: values.map(function (value) { return value.value }) })
+    t.equal(decodeCalls, values.length, 'each completed element is decoded once')
+  })
+
+  const encoded = pack.encode({ values })
+  for (let i = 0; i < encoded.length; i++) {
+    decoder.write(encoded.slice(i, i + 1))
+    maxBuffered = Math.max(maxBuffered, decoder._chunks.length)
+  }
+  t.ok(maxBuffered <= 6, 'only the current incomplete value remains buffered')
+  decoder.end()
+})
 test('nil processing works', function (t) {
   t.plan(3)