update devDependencies, update eslint config

[squeep-mystery-box] / lib / mystery-box.js

diff --git a/lib/mystery-box.js b/lib/mystery-box.js
index 5dcf1b1fe4dbc8486c62de6e0cf3cbd3be96f2a6..a2ea8a82b05919ccac0c166f681cfe2a64b56fce 100644 (file)
--- a/lib/mystery-box.js
+++ b/lib/mystery-box.js
@@ -4,7 +4,7 @@ const { EventEmitter } = require('events');
 const crypto = require('crypto');
 const zlib = require('zlib');
 const { promisify } = require('util');
-const common = require('./common');
+const { MysteryBoxError } = require('./errors');
 const allVersions = require('./version-parameters');
 const { performance } = require('perf_hooks');
 const { name: packageName, version: packageVersion } = require('../package.json');
@@ -19,6 +19,7 @@ const brotliDecompressAsync = promisify(zlib.brotliDecompress);
 const deflateRawAsync = promisify(zlib.deflateRaw);
 const inflateRawAsync = promisify(zlib.inflateRaw);
 const scryptAsync = promisify(crypto.scrypt);
+const randomBytesAsync = promisify(crypto.randomBytes);
 
 /**
  * Only you will know what's inside your...
@@ -62,7 +63,6 @@ const compressionFlagsShift = 0;
 const payloadFlagsMask = (availableFlags.BufferPayload);
 const payloadFlagsShift = 7;
 
-
 class MysteryBox extends EventEmitter {
   /**
    * @param {Object} options
@@ -71,9 +71,9 @@ class MysteryBox extends EventEmitter {
    */
   constructor(options = {}, ...args) {
     super(...args);
-    this.secrets = common.ensureArray(options.encryptionSecret);
+    this.secrets = MysteryBox._ensureArray(options.encryptionSecret);
     if (!this.secrets.length) {
-      throw new Error('missing encryption secret');
+      throw new MysteryBoxError('missing encryption secret');
     }
 
     // Filter any unavailable algorithms
@@ -93,14 +93,29 @@ class MysteryBox extends EventEmitter {
     // Default to highest
     this.bestVersion = Number(Object.keys(this.versionParameters).sort().pop());
     if (Number.isNaN(this.bestVersion)) {
-      throw new Error('no supported versions available');
+      throw new MysteryBoxError('no supported versions available');
     }
 
     this.Flags = availableFlags;
     this.defaultFlags = 'defaultFlags' in options ? options.defaultFlags : availableFlags.Flate;
     if (this.defaultFlags < 0 || this.defaultFlags > 255) {
-      throw new RangeError('Invalid default flag value');
+      throw new MysteryBoxError('Invalid default flag value');
+    }
+  }
+
+
+  /**
+   * Return an array containing x if x is something and not an array
+   * @param {*} x
+   */
+  static _ensureArray(x) {
+    if (x === undefined) {
+      return [];
+    }
+    if (!Array.isArray(x)) {
+      return Array(x);
     }
+    return x;
   }
 
 
@@ -142,7 +157,7 @@ class MysteryBox extends EventEmitter {
         return scryptAsync(secret, salt, keyBytes);
 
       default:
-        throw new RangeError('unsupported key deriver');
+        throw new MysteryBoxError('unsupported key deriver');
     }
   }
 
@@ -187,7 +202,7 @@ class MysteryBox extends EventEmitter {
       }
     }
     // Nine bytes would be an extravagence.
-    throw new RangeError(`unsupported version header (0x${firstByte.toString(16)})`);
+    throw new MysteryBoxError(`unsupported version header (0x${firstByte.toString(16)})`);
   }
 
 
@@ -211,7 +226,7 @@ class MysteryBox extends EventEmitter {
     }
 
     if (versionBytes > 6) {
-      throw new RangeError(`unsupported version (${versionBytes} bytes)`);
+      throw new MysteryBoxError(`unsupported version (${versionBytes} bytes)`);
     }
 
     // Otherwise, update the masked first byte and parse the rest of the buffer.
@@ -244,7 +259,7 @@ class MysteryBox extends EventEmitter {
     } else if (version <= 0x03ffffffffff) { // 34359738368-4398046511103
       versionBytes = 6;
     } else {
-      throw new RangeError('version too large to encode');
+      throw new MysteryBoxError(`version too large to encode (${version})`);
     }
 
     const buffer = Buffer.alloc(versionBytes);
@@ -296,7 +311,7 @@ class MysteryBox extends EventEmitter {
     const { stats, timingsMs } = MysteryBox._newStats('pack');
 
     if (!(version in this.versionParameters)) {
-      throw new RangeError(`MysteryBox format version ${version} not supported`);
+      throw new MysteryBoxError(`MysteryBox format version ${version} not supported`);
     }
     // eslint-disable-next-line security/detect-object-injection
     const v = this.versionParameters[version];
@@ -320,13 +335,13 @@ class MysteryBox extends EventEmitter {
 
     const { buffer: versionBuffer, versionBytes } = MysteryBox._versionEncode(v.version);
     if (versionBytes !== v.versionBytes) {
-      throw new Error('internal inconsistency, mismatched version byte length');
+      throw new MysteryBoxError('internal inconsistency, mismatched version byte length');
     }
 
     const [iv, salt] = await Promise.all([
       v.ivBytes,
       v.saltBytes,
-    ].map((b) => common.randomBytesAsync(b)));
+    ].map((b) => randomBytesAsync(b)));
 
     timingsMs.preCompress = performance.now();
     let compressedContents;
@@ -390,7 +405,7 @@ class MysteryBox extends EventEmitter {
     const { stats, timingsMs } = MysteryBox._newStats('unpack');
 
     if (!box) {
-      throw new RangeError('nothing to unpack');
+      throw new MysteryBoxError('nothing to unpack');
     }
 
     const raw = Buffer.from(box, 'base64url');
@@ -398,20 +413,20 @@ class MysteryBox extends EventEmitter {
 
     const { version, versionBytes } = MysteryBox._versionDecode(raw);
     if (!(version in this.versionParameters)) {
-      throw new RangeError('unsupported version');
+      throw new MysteryBoxError(`unsupported version (${version})`);
     }
     // eslint-disable-next-line security/detect-object-injection
     const v = this.versionParameters[version];
 
     if (v.versionBytes !== versionBytes) {
-      throw new Error('internal inconsistency, mismatched version byte length');
+      throw new MysteryBoxError('internal inconsistency, mismatched version byte length');
     }
     offset += v.versionBytes;
     stats.version = version;
 
     const minBytes = v.versionBytes + v.flagsBytes + v.ivBytes + v.saltBytes + v.tagBytes;
     if (raw.length < minBytes) {
-      throw new RangeError('not enough to unpack');
+      throw new MysteryBoxError('not enough to unpack');
     }
 
     const flags = raw.subarray(offset, offset + v.flagsBytes).readUInt8(0);