@webex/internal-plugin-encryption 3.0.0-beta.8 → 3.0.0-bnr.0

package/src/encryption.js

@@ -15,7 +15,7 @@ import KMS from './kms';
 
 const Encryption = WebexPlugin.extend({
   children: {
-    kms: KMS
+    kms: KMS,
   },
 
   namespace: 'Encryption',
@@ -25,15 +25,14 @@ const Encryption = WebexPlugin.extend({
   },
 
   decryptBinary(scr, buffer) {
-    return ensureBuffer(buffer)
-      .then((b) => {
-        /* istanbul ignore if */
-        if (buffer.length === 0 || buffer.byteLength === 0) {
-          return Promise.reject(new Error('Attempted to decrypt zero-length buffer'));
-        }
-
-        return scr.decrypt(b);
-      });
+    return ensureBuffer(buffer).then((b) => {
+      /* istanbul ignore if */
+      if (buffer.length === 0 || buffer.byteLength === 0) {
+        return Promise.reject(new Error('Attempted to decrypt zero-length buffer'));
+      }
+
+      return scr.decrypt(b);
+    });
   },
 
   /**
@@ -46,8 +45,7 @@ const Encryption = WebexPlugin.extend({
    * @returns {Object} Decrypted SCR
    */
   decryptScr(key, cipherScr, options) {
-    return this.getKey(key, options)
-      .then((k) => SCR.fromJWE(k.jwk, cipherScr));
+    return this.getKey(key, options).then((k) => SCR.fromJWE(k.jwk, cipherScr));
   },
 
   /**
@@ -60,11 +58,11 @@ const Encryption = WebexPlugin.extend({
    * @returns {string} Decrypted plaintext
    */
   decryptText(key, ciphertext, options) {
-    return this.getKey(key, options)
-      .then((k) => jose.JWE
-        .createDecrypt(k.jwk)
+    return this.getKey(key, options).then((k) =>
+      jose.JWE.createDecrypt(k.jwk)
         .decrypt(ciphertext)
-        .then((result) => result.plaintext.toString()));
+        .then((result) => result.plaintext.toString())
+    );
   },
 
   /**
@@ -83,10 +81,11 @@ const Encryption = WebexPlugin.extend({
     const shunt = new EventEmitter();
     const promise = this._fetchDownloadUrl(scr, options)
       .then((uri) => {
+        // eslint-disable-next-line no-shadow
         const options = {
           method: 'GET',
           uri,
-          responseType: 'buffer'
+          responseType: 'buffer',
         };
 
         const ret = this.request(options);
@@ -113,13 +112,15 @@ const Encryption = WebexPlugin.extend({
     this.logger.info('encryption: retrieving download url for encrypted file');
 
     if (process.env.NODE_ENV !== 'production' && scr.loc.includes('localhost')) {
-      this.logger.info('encryption: bypassing webex files because this looks to be a test file on localhost');
+      this.logger.info(
+        'encryption: bypassing webex files because this looks to be a test file on localhost'
+      );
 
       return Promise.resolve(scr.loc);
     }
 
     const inputBody = {
-      endpoints: [scr.loc]
+      endpoints: [scr.loc],
     };
     const endpointUrl = url.parse(scr.loc);
 
@@ -130,32 +131,39 @@ const Encryption = WebexPlugin.extend({
     return this.request({
       method: 'POST',
       uri: url.format(endpointUrl),
-      body: options ? {
-        ...inputBody,
-        allow: options.params.allow
-      } : inputBody
-    })
-      .then((res) => {
-        const url = res.body.endpoints[scr.loc];
-
-        if (!url) {
-          this.logger.warn('encryption: could not determine download url for `scr.loc`; attempting to download `scr.loc` directly');
-
-          return scr.loc;
-        }
-        this.logger.info('encryption: retrieved download url for encrypted file');
-
-        return url;
-      });
+      body: options
+        ? {
+            ...inputBody,
+            allow: options.params.allow,
+          }
+        : inputBody,
+    }).then((res) => {
+      // eslint-disable-next-line no-shadow
+      const url = res.body.endpoints[scr.loc];
+
+      if (!url) {
+        this.logger.warn(
+          'encryption: could not determine download url for `scr.loc`; attempting to download `scr.loc` directly'
+        );
+
+        return scr.loc;
+      }
+      this.logger.info('encryption: retrieved download url for encrypted file');
+
+      return url;
+    });
   },
 
   encryptBinary(file) {
-    return ensureBuffer(file)
-      .then((buffer) => SCR.create()
-        .then((scr) => scr.encrypt(buffer)
+    return ensureBuffer(file).then((buffer) =>
+      SCR.create().then((scr) =>
+        scr
+          .encrypt(buffer)
           .then(ensureBuffer)
           // eslint-disable-next-line max-nested-callbacks
-          .then((cdata) => ({scr, cdata}))));
+          .then((cdata) => ({scr, cdata}))
+      )
+    );
   },
 
   /**
@@ -173,8 +181,7 @@ const Encryption = WebexPlugin.extend({
       return Promise.reject(new Error('Cannot encrypt `scr` without first setting `loc`'));
     }
 
-    return this.getKey(key, options)
-      .then((k) => scr.toJWE(k.jwk));
+    return this.getKey(key, options).then((k) => scr.toJWE(k.jwk));
   },
 
   /**
@@ -187,16 +194,15 @@ const Encryption = WebexPlugin.extend({
    * @returns {string} Encrypted text
    */
   encryptText(key, plaintext, options) {
-    return this.getKey(key, options)
-      .then((k) => jose.JWE
-        .createEncrypt(this.config.joseOptions, {
-          key: k.jwk,
-          header: {
-            alg: 'dir'
-          },
-          reference: null
-        })
-        .final(plaintext, 'utf8'));
+    return this.getKey(key, options).then((k) =>
+      jose.JWE.createEncrypt(this.config.joseOptions, {
+        key: k.jwk,
+        header: {
+          alg: 'dir',
+        },
+        reference: null,
+      }).final(plaintext, 'utf8')
+    );
   },
 
   /**
@@ -218,12 +224,16 @@ const Encryption = WebexPlugin.extend({
       storageKey += `/onBehalfOf/${onBehalfOf}`;
     }
 
-    return this.unboundedStorage.get(storageKey)
+    return this.unboundedStorage
+      .get(storageKey)
       .then((keyString) => JSON.parse(keyString))
       .then((keyObject) => this.kms.asKey(keyObject))
-      .catch(() => this.kms.fetchKey({uri, onBehalfOf})
-        .then(tap((key) => this.unboundedStorage.put(storageKey, JSON.stringify(key, replacer)))));
-  }
+      .catch(() =>
+        this.kms
+          .fetchKey({uri, onBehalfOf})
+          .then(tap((key) => this.unboundedStorage.put(storageKey, JSON.stringify(key, replacer))))
+      );
+  },
 });
 
 /**

package/src/ensure-buffer.browser.js

@@ -3,7 +3,6 @@
  */
 
 /* eslint-env: browser */
-/* global FileReader */
 
 /**
  * Ensures the provider buffer is, indeed, an ArrayBuffer; converts File and

package/src/ensure-buffer.js

@@ -5,11 +5,11 @@
 import {isBuffer} from '@webex/common';
 
 /**
-* Ensures the provider Buffer is, indeed, a Buffer; sometimes, they seem to be
-* byte-arrays instead of proper Buffer objects.
-* @param {mixed} buffer
-* @returns {Promise<Buffer>}
-*/
+ * Ensures the provider Buffer is, indeed, a Buffer; sometimes, they seem to be
+ * byte-arrays instead of proper Buffer objects.
+ * @param {mixed} buffer
+ * @returns {Promise<Buffer>}
+ */
 export default function ensureBuffer(buffer) {
   /* istanbul ignore if */
   if (!isBuffer(buffer)) {

package/src/index.js

@@ -8,126 +8,150 @@
 // by using Promise.race to resolve replays (as more requests get enqueue for a
 // specific action, accept whichever one completes first).
 
+import '@webex/internal-plugin-device';
+
+import '@webex/internal-plugin-mercury';
+
 import {registerInternalPlugin} from '@webex/webex-core';
 import {has, isObject, isString} from 'lodash';
 
 import Encryption from './encryption';
 import config from './config';
 import {DryError} from './kms-errors';
-import '@webex/internal-plugin-device';
-import '@webex/internal-plugin-mercury';
+
 import KmsDryErrorInterceptor from './kms-dry-error-interceptor';
 
 let interceptors;
 
 if (process.env.NODE_ENV === 'test') {
   interceptors = {
-    KmsDryErrorInterceptor: KmsDryErrorInterceptor.create
+    KmsDryErrorInterceptor: KmsDryErrorInterceptor.create,
   };
 }
 
 registerInternalPlugin('encryption', Encryption, {
   payloadTransformer: {
-    predicates: [{
-      name: 'encryptKmsMessage',
-      direction: 'outbound',
-      // I don't see any practical way to reduce complexity here.
-      // eslint-disable-next-line complexity
-      test(ctx, options) {
-        if (!has(options, 'body.kmsMessage')) {
-          return Promise.resolve(false);
-        }
-
-        if (!isObject(options.body.kmsMessage)) {
-          return Promise.resolve(false);
-        }
-
-        // If this is a template for a kms message, assume another transform
-        // will fill it in later. This is a bit of a leaky abstraction, but the
-        // alternative is building a complex rules engine for controlling
-        // ordering of transforms
-        if (options.body.kmsMessage.keyUris && options.body.kmsMessage.keyUris.length === 0) {
-          return Promise.resolve(false);
-        }
-        if (options.body.kmsMessage.resourceUri && (options.body.kmsMessage.resourceUri.includes('<KRO>') || options.body.kmsMessage.resourceUri.includes('<KEYURL>'))) {
-          return Promise.resolve(false);
-        }
-        if (options.body.kmsMessage.uri && (options.body.kmsMessage.uri.includes('<KRO>') || options.body.kmsMessage.uri.includes('<KEYURL>'))) {
-          return Promise.resolve(false);
-        }
-
-        return Promise.resolve(true);
+    predicates: [
+      {
+        name: 'encryptKmsMessage',
+        direction: 'outbound',
+        // I don't see any practical way to reduce complexity here.
+        // eslint-disable-next-line complexity
+        test(ctx, options) {
+          if (!has(options, 'body.kmsMessage')) {
+            return Promise.resolve(false);
+          }
+
+          if (!isObject(options.body.kmsMessage)) {
+            return Promise.resolve(false);
+          }
+
+          // If this is a template for a kms message, assume another transform
+          // will fill it in later. This is a bit of a leaky abstraction, but the
+          // alternative is building a complex rules engine for controlling
+          // ordering of transforms
+          if (options.body.kmsMessage.keyUris && options.body.kmsMessage.keyUris.length === 0) {
+            return Promise.resolve(false);
+          }
+          if (
+            options.body.kmsMessage.resourceUri &&
+            (options.body.kmsMessage.resourceUri.includes('<KRO>') ||
+              options.body.kmsMessage.resourceUri.includes('<KEYURL>'))
+          ) {
+            return Promise.resolve(false);
+          }
+          if (
+            options.body.kmsMessage.uri &&
+            (options.body.kmsMessage.uri.includes('<KRO>') ||
+              options.body.kmsMessage.uri.includes('<KEYURL>'))
+          ) {
+            return Promise.resolve(false);
+          }
+
+          return Promise.resolve(true);
+        },
+        extract(options) {
+          return Promise.resolve(options.body);
+        },
       },
-      extract(options) {
-        return Promise.resolve(options.body);
-      }
-    }, {
-      name: 'decryptKmsMessage',
-      direction: 'inbound',
-      test(ctx, response) {
-        return Promise.resolve(has(response, 'body.kmsMessage') && isString(response.body.kmsMessage));
+      {
+        name: 'decryptKmsMessage',
+        direction: 'inbound',
+        test(ctx, response) {
+          return Promise.resolve(
+            has(response, 'body.kmsMessage') && isString(response.body.kmsMessage)
+          );
+        },
+        extract(response) {
+          return Promise.resolve(response.body);
+        },
       },
-      extract(response) {
-        return Promise.resolve(response.body);
-      }
-    }, {
-      name: 'decryptErrorResponse',
-      direction: 'inbound',
-      test(ctx, reason) {
-        return Promise.resolve(Boolean(reason.body && reason.body.errorCode === 1900000));
+      {
+        name: 'decryptErrorResponse',
+        direction: 'inbound',
+        test(ctx, reason) {
+          return Promise.resolve(Boolean(reason.body && reason.body.errorCode === 1900000));
+        },
+        extract(reason) {
+          return Promise.resolve(reason);
+        },
       },
-      extract(reason) {
-        return Promise.resolve(reason);
-      }
-    }],
-    transforms: [{
-      name: 'encryptKmsMessage',
-      fn(ctx, object) {
-        if (!object) {
-          return Promise.resolve();
-        }
-
-        if (!object.kmsMessage) {
-          return Promise.resolve();
-        }
-
-        if (isString(object.kmsMessage)) {
-          return Promise.resolve();
-        }
-
-        return ctx.webex.internal.encryption.kms.prepareRequest(object.kmsMessage)
-          .then((req) => {
+    ],
+    transforms: [
+      {
+        name: 'encryptKmsMessage',
+        fn(ctx, object) {
+          if (!object) {
+            return Promise.resolve();
+          }
+
+          if (!object.kmsMessage) {
+            return Promise.resolve();
+          }
+
+          if (isString(object.kmsMessage)) {
+            return Promise.resolve();
+          }
+
+          return ctx.webex.internal.encryption.kms.prepareRequest(object.kmsMessage).then((req) => {
             object.kmsMessage = req.wrapped;
           });
-      }
-    }, {
-      name: 'decryptKmsMessage',
-      fn(ctx, object) {
-        return ctx.webex.internal.encryption.kms.decryptKmsMessage(object.kmsMessage)
-          .then((kmsMessage) => {
-            object.kmsMessage = kmsMessage;
-          });
-      }
-    }, {
-      name: 'decryptErrorResponse',
-      fn(ctx, reason) {
-        const promises = reason.body.errors.map((error) => ctx.webex.internal.encryption.kms.decryptKmsMessage(error.description)
-          .then((desc) => {
-            error.description = desc;
-          }));
-
-        promises.push(ctx.webex.internal.encryption.kms.decryptKmsMessage(reason.body.message)
-          .then((kmsMessage) => {
-            reason.body.message = kmsMessage;
-          }));
-
-        return Promise.all(promises)
-          .then(() => Promise.reject(new DryError(reason)));
-      }
-    }]
+        },
+      },
+      {
+        name: 'decryptKmsMessage',
+        fn(ctx, object) {
+          return ctx.webex.internal.encryption.kms
+            .decryptKmsMessage(object.kmsMessage)
+            .then((kmsMessage) => {
+              object.kmsMessage = kmsMessage;
+            });
+        },
+      },
+      {
+        name: 'decryptErrorResponse',
+        fn(ctx, reason) {
+          const promises = reason.body.errors.map((error) =>
+            ctx.webex.internal.encryption.kms.decryptKmsMessage(error.description).then((desc) => {
+              error.description = desc;
+            })
+          );
+
+          promises.push(
+            ctx.webex.internal.encryption.kms
+              .decryptKmsMessage(reason.body.message)
+              .then((kmsMessage) => {
+                reason.body.message = kmsMessage;
+              })
+          );
+
+          return Promise.all(promises).then(() => Promise.reject(new DryError(reason)));
+        },
+      },
+    ],
   },
   interceptors,
-  config
+  config,
 });
 
 export {default} from './encryption';

package/src/kms-batcher.js

@@ -23,14 +23,19 @@ const KmsBatcher = Batcher.extend({
   processKmsMessageEvent(event) {
     this.logger.info('kms-batcher: received kms message');
 
-    return Promise.all(event.encryption.kmsMessages.map((kmsMessage) => new Promise((resolve) => {
-      /* istanbul ignore else */
-      if (process.env.NODE_ENV !== 'production') {
-        this.logger.info('kms-batcher:', kmsMessage.body);
-      }
-
-      resolve(this.acceptItem(kmsMessage));
-    })));
+    return Promise.all(
+      event.encryption.kmsMessages.map(
+        (kmsMessage) =>
+          new Promise((resolve) => {
+            /* istanbul ignore else */
+            if (process.env.NODE_ENV !== 'production') {
+              this.logger.info('kms-batcher:', kmsMessage.body);
+            }
+
+            resolve(this.acceptItem(kmsMessage));
+          })
+      )
+    );
   },
 
   /**
@@ -39,30 +44,34 @@ const KmsBatcher = Batcher.extend({
    * @returns {Promise<Object>}
    */
   prepareItem(item) {
-    return this.getDeferredForRequest(item)
-      .then((defer) => {
-        const timeout = item[TIMEOUT_SYMBOL];
-
-        /* istanbul ignore if */
-        if (!timeout) {
-          throw new Error('timeout is required');
-        }
-
-        const timer = safeSetTimeout(() => {
-          this.logger.warn(`kms: request timed out; request id: ${item.requestId}; timeout: ${timeout}`);
-          this.handleItemFailure(item, new KmsTimeoutError({
+    return this.getDeferredForRequest(item).then((defer) => {
+      const timeout = item[TIMEOUT_SYMBOL];
+
+      /* istanbul ignore if */
+      if (!timeout) {
+        throw new Error('timeout is required');
+      }
+
+      const timer = safeSetTimeout(() => {
+        this.logger.warn(
+          `kms: request timed out; request id: ${item.requestId}; timeout: ${timeout}`
+        );
+        this.handleItemFailure(
+          item,
+          new KmsTimeoutError({
             timeout,
-            request: item
-          }));
-        }, timeout);
+            request: item,
+          })
+        );
+      }, timeout);
 
-        // Reminder: reassign `promise` is not a viable means of inserting into
-        // the Promise chain
-        defer.promise.then(() => clearTimeout(timer));
-        defer.promise.catch(() => clearTimeout(timer));
+      // Reminder: reassign `promise` is not a viable means of inserting into
+      // the Promise chain
+      defer.promise.then(() => clearTimeout(timer));
+      defer.promise.catch(() => clearTimeout(timer));
 
-        return item;
-      });
+      return item;
+    });
   },
 
   /**
@@ -71,11 +80,10 @@ const KmsBatcher = Batcher.extend({
    * @returns {Promise<Array>}
    */
   prepareRequest(queue) {
-    return this.webex.internal.encryption.kms._getKMSCluster()
-      .then((cluster) => ({
-        destination: cluster,
-        kmsMessages: queue.map((req) => req.wrapped)
-      }));
+    return this.webex.internal.encryption.kms._getKMSCluster().then((cluster) => ({
+      destination: cluster,
+      kmsMessages: queue.map((req) => req.wrapped),
+    }));
   },
 
   /**
@@ -89,7 +97,7 @@ const KmsBatcher = Batcher.extend({
       method: 'POST',
       service: 'encryption',
       resource: '/kms/messages',
-      body: payload
+      body: payload,
     });
   },
 
@@ -114,10 +122,9 @@ const KmsBatcher = Batcher.extend({
    * @returns {Promise}
    */
   handleItemSuccess(item) {
-    return this.getDeferredForResponse(item)
-      .then((defer) => {
-        defer.resolve(item.body);
-      });
+    return this.getDeferredForResponse(item).then((defer) => {
+      defer.resolve(item.body);
+    });
   },
 
   /**
@@ -126,10 +133,9 @@ const KmsBatcher = Batcher.extend({
    * @returns {Promise}
    */
   handleItemFailure(item, reason) {
-    return this.getDeferredForResponse(item)
-      .then((defer) => {
-        defer.reject(reason || new KmsError(item.body));
-      });
+    return this.getDeferredForResponse(item).then((defer) => {
+      defer.reject(reason || new KmsError(item.body));
+    });
   },
 
   /**
@@ -146,7 +152,7 @@ const KmsBatcher = Batcher.extend({
    */
   fingerprintResponse(item) {
     return Promise.resolve(item.requestId);
-  }
+  },
 });
 
 export default KmsBatcher;