@weavecode/weave 0.0.0-stage → 0.1.1

package/node_modules/web-push/src/cli.js

@@ -0,0 +1,131 @@
+#! /usr/bin/env node
+/* eslint consistent-return:0 */
+
+'use strict';
+
+const webPush = require('../src/index.js');
+
+const printUsageDetails = () => {
+  const actions = [
+    {
+      name: 'send-notification',
+      options: [
+        '--endpoint=<url>',
+        '[--key=<browser key>]',
+        '[--auth=<auth secret>]',
+        '[--payload=<message>]',
+        '[--ttl=<seconds>]',
+        '[--encoding=<encoding type>]',
+        '[--vapid-subject=<vapid subject>]',
+        '[--vapid-pubkey=<public key url base64>]',
+        '[--vapid-pvtkey=<private key url base64>]',
+        '[--proxy=<http proxy uri, e.g: http://127.0.0.1:8889>]',
+        '[--gcm-api-key=<api key>]'
+      ]
+    }, {
+      name: 'generate-vapid-keys',
+      options: [
+        '[--json]'
+      ]
+    }
+  ];
+
+  let usage = '\nUsage: \n\n';
+  actions.forEach(action => {
+    usage += '  web-push ' + action.name;
+    usage += ' ' + action.options.join(' ');
+    usage += '\n\n';
+  });
+
+  console.log(usage);
+  process.exit(1);
+};
+
+const generateVapidKeys = returnJson => {
+  const vapidKeys = webPush.generateVAPIDKeys();
+
+  let outputText;
+  if (returnJson) {
+    outputText = JSON.stringify(vapidKeys);
+  } else {
+    const outputLine = '\n=======================================\n';
+    outputText = outputLine + '\n'
+    + 'Public Key:\n' + vapidKeys.publicKey + '\n\n'
+    + 'Private Key:\n' + vapidKeys.privateKey + '\n'
+    + outputLine;
+  }
+
+  console.log(outputText);
+  process.exit(0);
+};
+
+const sendNotification = args => {
+  if (process.env.GCM_API_KEY) {
+    webPush.setGCMAPIKey(process.env.GCM_API_KEY);
+  }
+
+  const subscription = {
+    endpoint: args.endpoint,
+    keys: {
+      p256dh: args.key || null,
+      auth: args.auth || null
+    }
+  };
+
+  const payload = args.payload || null;
+
+  const options = {};
+
+  if (args.ttl) {
+    options.TTL = args.ttl;
+  }
+
+  if (argv['vapid-subject'] || argv['vapid-pubkey'] || argv['vapid-pvtkey']) {
+    options.vapidDetails = {
+      subject: args['vapid-subject'] || null,
+      publicKey: args['vapid-pubkey'] || null,
+      privateKey: args['vapid-pvtkey'] || null
+    };
+  }
+
+  if (args.proxy) {
+    options.proxy = args.proxy;
+  }
+
+  if (args['gcm-api-key']) {
+    options.gcmAPIKey = args['gcm-api-key'];
+  }
+
+  if (args.encoding) {
+    options.contentEncoding = args.encoding;
+  }
+
+  webPush.sendNotification(subscription, payload, options)
+  .then(() => {
+    console.log('Push message sent.');
+  }, err => {
+    console.log('Error sending push message: ');
+    console.log(err);
+  })
+  .then(() => {
+    process.exit(0);
+  });
+};
+
+const action = process.argv[2];
+const argv = require('minimist')(process.argv.slice(3));
+switch (action) {
+  case 'send-notification':
+    if (!argv.endpoint) {
+      return printUsageDetails();
+    }
+
+    sendNotification(argv);
+    break;
+  case 'generate-vapid-keys':
+    generateVapidKeys(argv.json || false);
+    break;
+  default:
+    printUsageDetails();
+    break;
+}

package/node_modules/web-push/src/encryption-helper.js

@@ -0,0 +1,62 @@
+'use strict';
+
+const crypto = require('crypto');
+const ece = require('http_ece');
+
+const encrypt = function(userPublicKey, userAuth, payload, contentEncoding) {
+  if (!userPublicKey) {
+    throw new Error('No user public key provided for encryption.');
+  }
+
+  if (typeof userPublicKey !== 'string') {
+    throw new Error('The subscription p256dh value must be a string.');
+  }
+
+  if (Buffer.from(userPublicKey, 'base64url').length !== 65) {
+    throw new Error('The subscription p256dh value should be 65 bytes long.');
+  }
+
+  if (!userAuth) {
+    throw new Error('No user auth provided for encryption.');
+  }
+
+  if (typeof userAuth !== 'string') {
+    throw new Error('The subscription auth key must be a string.');
+  }
+
+  if (Buffer.from(userAuth, 'base64url').length < 16) {
+    throw new Error('The subscription auth key should be at least 16 '
+    + 'bytes long');
+  }
+
+  if (typeof payload !== 'string' && !Buffer.isBuffer(payload)) {
+    throw new Error('Payload must be either a string or a Node Buffer.');
+  }
+
+  if (typeof payload === 'string' || payload instanceof String) {
+    payload = Buffer.from(payload);
+  }
+
+  const localCurve = crypto.createECDH('prime256v1');
+  const localPublicKey = localCurve.generateKeys();
+
+  const salt = crypto.randomBytes(16).toString('base64url');
+
+  const cipherText = ece.encrypt(payload, {
+    version: contentEncoding,
+    dh: userPublicKey,
+    privateKey: localCurve,
+    salt: salt,
+    authSecret: userAuth
+  });
+
+  return {
+    localPublicKey: localPublicKey,
+    salt: salt,
+    cipherText: cipherText
+  };
+};
+
+module.exports = {
+  encrypt: encrypt
+};

package/node_modules/web-push/src/index.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const vapidHelper = require('./vapid-helper.js');
+const encryptionHelper = require('./encryption-helper.js');
+const WebPushLib = require('./web-push-lib.js');
+const WebPushError = require('./web-push-error.js');
+const WebPushConstants = require('./web-push-constants.js');
+
+const webPush = new WebPushLib();
+
+module.exports = {
+  WebPushError: WebPushError,
+  supportedContentEncodings: WebPushConstants.supportedContentEncodings,
+  encrypt: encryptionHelper.encrypt,
+  getVapidHeaders: vapidHelper.getVapidHeaders,
+  generateVAPIDKeys: vapidHelper.generateVAPIDKeys,
+  setGCMAPIKey: webPush.setGCMAPIKey,
+  setVapidDetails: webPush.setVapidDetails,
+  generateRequestDetails: webPush.generateRequestDetails,
+  sendNotification: webPush.sendNotification.bind(webPush)
+};

package/node_modules/web-push/src/urlsafe-base64-helper.js

@@ -0,0 +1,13 @@
+'use strict';
+
+/**
+ * @param {string} base64
+ * @returns {boolean}
+ */
+function validate(base64) {
+  return /^[A-Za-z0-9\-_]+$/.test(base64);
+}
+
+module.exports = {
+  validate: validate
+};

package/node_modules/web-push/src/vapid-helper.js

@@ -0,0 +1,255 @@
+'use strict';
+
+const crypto = require('crypto');
+const asn1 = require('asn1.js');
+const jws = require('jws');
+const { URL } = require('url');
+
+const WebPushConstants = require('./web-push-constants.js');
+const urlBase64Helper = require('./urlsafe-base64-helper');
+
+/**
+ * DEFAULT_EXPIRATION is set to seconds in 12 hours
+ */
+const DEFAULT_EXPIRATION_SECONDS = 12 * 60 * 60;
+
+// Maximum expiration is 24 hours according. (See VAPID spec)
+const MAX_EXPIRATION_SECONDS = 24 * 60 * 60;
+
+const ECPrivateKeyASN = asn1.define('ECPrivateKey', function() {
+  this.seq().obj(
+    this.key('version').int(),
+    this.key('privateKey').octstr(),
+    this.key('parameters').explicit(0).objid()
+      .optional(),
+    this.key('publicKey').explicit(1).bitstr()
+      .optional()
+  );
+});
+
+function toPEM(key) {
+  return ECPrivateKeyASN.encode({
+    version: 1,
+    privateKey: key,
+    parameters: [1, 2, 840, 10045, 3, 1, 7] // prime256v1
+  }, 'pem', {
+    label: 'EC PRIVATE KEY'
+  });
+}
+
+function generateVAPIDKeys() {
+  const curve = crypto.createECDH('prime256v1');
+  curve.generateKeys();
+
+  let publicKeyBuffer = curve.getPublicKey();
+  let privateKeyBuffer = curve.getPrivateKey();
+
+  // Occassionally the keys will not be padded to the correct lengh resulting
+  // in errors, hence this padding.
+  // See https://github.com/web-push-libs/web-push/issues/295 for history.
+  if (privateKeyBuffer.length < 32) {
+    const padding = Buffer.alloc(32 - privateKeyBuffer.length);
+    padding.fill(0);
+    privateKeyBuffer = Buffer.concat([padding, privateKeyBuffer]);
+  }
+
+  if (publicKeyBuffer.length < 65) {
+    const padding = Buffer.alloc(65 - publicKeyBuffer.length);
+    padding.fill(0);
+    publicKeyBuffer = Buffer.concat([padding, publicKeyBuffer]);
+  }
+
+  return {
+    publicKey: publicKeyBuffer.toString('base64url'),
+    privateKey: privateKeyBuffer.toString('base64url')
+  };
+}
+
+function validateSubject(subject) {
+  if (!subject) {
+    throw new Error('No subject set in vapidDetails.subject.');
+  }
+
+  if (typeof subject !== 'string' || subject.length === 0) {
+    throw new Error('The subject value must be a string containing an https: URL or '
+    + 'mailto: address. ' + subject);
+  }
+
+  let subjectParseResult = null;
+  try {
+    subjectParseResult = new URL(subject);
+  } catch (err) {
+    throw new Error('Vapid subject is not a valid URL. ' + subject);
+  }
+  if (!['https:', 'mailto:'].includes(subjectParseResult.protocol)) {
+    throw new Error('Vapid subject is not an https: or mailto: URL. ' + subject);
+  }
+  if (subjectParseResult.hostname === 'localhost') {
+    console.warn('Vapid subject points to a localhost web URI, which is unsupported by '
+      + 'Apple\'s push notification server and will result in a BadJwtToken error when '
+      + 'sending notifications.');
+    }
+}
+
+function validatePublicKey(publicKey) {
+  if (!publicKey) {
+    throw new Error('No key set vapidDetails.publicKey');
+  }
+
+  if (typeof publicKey !== 'string') {
+    throw new Error('Vapid public key is must be a URL safe Base 64 '
+    + 'encoded string.');
+  }
+
+  if (!urlBase64Helper.validate(publicKey)) {
+    throw new Error('Vapid public key must be a URL safe Base 64 (without "=")');
+  }
+
+  publicKey = Buffer.from(publicKey, 'base64url');
+
+  if (publicKey.length !== 65) {
+    throw new Error('Vapid public key should be 65 bytes long when decoded.');
+  }
+}
+
+function validatePrivateKey(privateKey) {
+  if (!privateKey) {
+    throw new Error('No key set in vapidDetails.privateKey');
+  }
+
+  if (typeof privateKey !== 'string') {
+    throw new Error('Vapid private key must be a URL safe Base 64 '
+    + 'encoded string.');
+  }
+
+  if (!urlBase64Helper.validate(privateKey)) {
+    throw new Error('Vapid private key must be a URL safe Base 64 (without "=")');
+  }
+
+  privateKey = Buffer.from(privateKey, 'base64url');
+
+  if (privateKey.length !== 32) {
+    throw new Error('Vapid private key should be 32 bytes long when decoded.');
+  }
+}
+
+/**
+ * Given the number of seconds calculates
+ * the expiration in the future by adding the passed `numSeconds`
+ * with the current seconds from Unix Epoch
+ *
+ * @param {Number} numSeconds Number of seconds to be added
+ * @return {Number} Future expiration in seconds
+ */
+function getFutureExpirationTimestamp(numSeconds) {
+  const futureExp = new Date();
+  futureExp.setSeconds(futureExp.getSeconds() + numSeconds);
+  return Math.floor(futureExp.getTime() / 1000);
+}
+
+/**
+ * Validates the Expiration Header based on the VAPID Spec
+ * Throws error of type `Error` if the expiration is not validated
+ *
+ * @param {Number} expiration Expiration seconds from Epoch to be validated
+ */
+function validateExpiration(expiration) {
+  if (!Number.isInteger(expiration)) {
+    throw new Error('`expiration` value must be a number');
+  }
+
+  if (expiration < 0) {
+    throw new Error('`expiration` must be a positive integer');
+  }
+
+  // Roughly checks the time of expiration, since the max expiration can be ahead
+  // of the time than at the moment the expiration was generated
+  const maxExpirationTimestamp = getFutureExpirationTimestamp(MAX_EXPIRATION_SECONDS);
+
+  if (expiration >= maxExpirationTimestamp) {
+    throw new Error('`expiration` value is greater than maximum of 24 hours');
+  }
+}
+
+/**
+ * This method takes the required VAPID parameters and returns the required
+ * header to be added to a Web Push Protocol Request.
+ * @param  {string} audience        This must be the origin of the push service.
+ * @param  {string} subject         This should be a URL or a 'mailto:' email
+ * address.
+ * @param  {string} publicKey       The VAPID public key.
+ * @param  {string} privateKey      The VAPID private key.
+ * @param  {string} contentEncoding The contentEncoding type.
+ * @param  {integer} [expiration]   The expiration of the VAPID JWT.
+ * @return {Object}                 Returns an Object with the Authorization and
+ * 'Crypto-Key' values to be used as headers.
+ */
+function getVapidHeaders(audience, subject, publicKey, privateKey, contentEncoding, expiration) {
+  if (!audience) {
+    throw new Error('No audience could be generated for VAPID.');
+  }
+
+  if (typeof audience !== 'string' || audience.length === 0) {
+    throw new Error('The audience value must be a string containing the '
+    + 'origin of a push service. ' + audience);
+  }
+
+  try {
+    new URL(audience); // eslint-disable-line no-new
+  } catch (err) {
+    throw new Error('VAPID audience is not a url. ' + audience);
+  }
+
+  validateSubject(subject);
+  validatePublicKey(publicKey);
+  validatePrivateKey(privateKey);
+
+  privateKey = Buffer.from(privateKey, 'base64url');
+
+  if (expiration) {
+    validateExpiration(expiration);
+  } else {
+    expiration = getFutureExpirationTimestamp(DEFAULT_EXPIRATION_SECONDS);
+  }
+
+  const header = {
+    typ: 'JWT',
+    alg: 'ES256'
+  };
+
+  const jwtPayload = {
+    aud: audience,
+    exp: expiration,
+    sub: subject
+  };
+
+  const jwt = jws.sign({
+    header: header,
+    payload: jwtPayload,
+    privateKey: toPEM(privateKey)
+  });
+
+  if (contentEncoding === WebPushConstants.supportedContentEncodings.AES_128_GCM) {
+    return {
+      Authorization: 'vapid t=' + jwt + ', k=' + publicKey
+    };
+  }
+  if (contentEncoding === WebPushConstants.supportedContentEncodings.AES_GCM) {
+    return {
+      Authorization: 'WebPush ' + jwt,
+      'Crypto-Key': 'p256ecdsa=' + publicKey
+    };
+  }
+
+  throw new Error('Unsupported encoding type specified.');
+}
+
+module.exports = {
+  generateVAPIDKeys: generateVAPIDKeys,
+  getFutureExpirationTimestamp: getFutureExpirationTimestamp,
+  getVapidHeaders: getVapidHeaders,
+  validateSubject: validateSubject,
+  validatePublicKey: validatePublicKey,
+  validatePrivateKey: validatePrivateKey,
+  validateExpiration: validateExpiration
+};

package/node_modules/web-push/src/web-push-constants.js

@@ -0,0 +1,17 @@
+'use strict';
+
+const WebPushConstants = {};
+
+WebPushConstants.supportedContentEncodings = {
+  AES_GCM: 'aesgcm',
+  AES_128_GCM: 'aes128gcm'
+};
+
+WebPushConstants.supportedUrgency = {
+  VERY_LOW: 'very-low',
+  LOW: 'low',
+  NORMAL: 'normal',
+  HIGH: 'high'
+};
+
+module.exports = WebPushConstants;

package/node_modules/web-push/src/web-push-error.js

@@ -0,0 +1,16 @@
+'use strict';
+
+function WebPushError(message, statusCode, headers, body, endpoint) {
+  Error.captureStackTrace(this, this.constructor);
+
+  this.name = this.constructor.name;
+  this.message = message;
+  this.statusCode = statusCode;
+  this.headers = headers;
+  this.body = body;
+  this.endpoint = endpoint;
+}
+
+require('util').inherits(WebPushError, Error);
+
+module.exports = WebPushError;