@rustwirebot/rustplus.js 2.5.0

package/vendor/push-receiver/client.js

@@ -0,0 +1,216 @@
+const EventEmitter = require('events');
+const Long = require('long');
+const Parser = require('./parser');
+const decrypt = require('./utils/decrypt');
+const path = require('path');
+const tls = require('tls');
+const { checkIn } = require('./gcm');
+const {
+  kMCSVersion,
+  kLoginRequestTag,
+  kDataMessageStanzaTag,
+  kLoginResponseTag,
+} = require('./constants');
+const { load } = require('protobufjs');
+
+const HOST = 'mtalk.google.com';
+const PORT = 5228;
+const MAX_RETRY_TIMEOUT = 15;
+
+let proto = null;
+
+module.exports = class Client extends EventEmitter {
+  static async init() {
+    if (proto) {
+      return;
+    }
+    proto = await load(path.resolve(__dirname, 'mcs.proto'));
+  }
+
+  constructor(androidId, securityToken, persistentIds) {
+    super();
+    this._androidId = androidId;
+    this._securityToken = securityToken;
+    this._persistentIds = persistentIds || [];
+    this._retryCount = 0;
+    this._onSocketConnect = this._onSocketConnect.bind(this);
+    this._onSocketClose = this._onSocketClose.bind(this);
+    this._onSocketError = this._onSocketError.bind(this);
+    this._onMessage = this._onMessage.bind(this);
+    this._onParserError = this._onParserError.bind(this);
+  }
+
+  async connect() {
+    await Client.init();
+    await this._checkIn();
+    this._connect();
+    // can happen if the socket immediately closes after being created
+    if (!this._socket) {
+      return;
+    }
+    await Parser.init();
+    // can happen if the socket immediately closes after being created
+    if (!this._socket) {
+      return;
+    }
+    this._parser = new Parser(this._socket);
+    this._parser.on('message', this._onMessage);
+    this._parser.on('error', this._onParserError);
+  }
+
+  destroy() {
+    this._destroy();
+  }
+
+  async _checkIn() {
+    return checkIn(
+      this._androidId,
+      this._securityToken,
+    );
+  }
+
+  _connect() {
+    this._socket = new tls.TLSSocket();
+    this._socket.setKeepAlive(true);
+    this._socket.on('connect', this._onSocketConnect);
+    this._socket.on('close', this._onSocketClose);
+    this._socket.on('error', this._onSocketError);
+    this._socket.connect({ host : HOST, port : PORT });
+    this._socket.write(this._loginBuffer());
+  }
+
+  _destroy() {
+    clearTimeout(this._retryTimeout);
+    if (this._socket) {
+      this._socket.removeListener('connect', this._onSocketConnect);
+      this._socket.removeListener('close', this._onSocketClose);
+      this._socket.removeListener('error', this._onSocketError);
+      this._socket.destroy();
+      this._socket = null;
+    }
+    if (this._parser) {
+      this._parser.removeListener('message', this._onMessage);
+      this._parser.removeListener('error', this._onParserError);
+      this._parser.destroy();
+      this._parser = null;
+    }
+  }
+
+  _loginBuffer() {
+    const LoginRequestType = proto.lookupType('mcs_proto.LoginRequest');
+    const hexAndroidId = Long.fromString(
+      this._androidId
+    ).toString(16);
+    const loginRequest = {
+      adaptiveHeartbeat    : false,
+      authService          : 2,
+      authToken            : this._securityToken,
+      id                   : 'chrome-63.0.3234.0',
+      domain               : 'mcs.android.com',
+      deviceId             : `android-${hexAndroidId}`,
+      networkType          : 1,
+      resource             : this._androidId,
+      user                 : this._androidId,
+      useRmq2              : true,
+      setting              : [{ name : 'new_vc', value : '1' }],
+      // Id of the last notification received
+      clientEvent          : [],
+      receivedPersistentId : this._persistentIds,
+    };
+
+    const errorMessage = LoginRequestType.verify(loginRequest);
+    if (errorMessage) {
+      throw new Error(errorMessage);
+    }
+
+    const buffer = LoginRequestType.encodeDelimited(loginRequest).finish();
+
+    return Buffer.concat([
+      Buffer.from([kMCSVersion, kLoginRequestTag]),
+      buffer,
+    ]);
+  }
+
+  _onSocketConnect() {
+    this._retryCount = 0;
+    this.emit('connect');
+  }
+
+  _onSocketClose() {
+    this.emit('disconnect');
+    this._retry();
+  }
+
+  _onSocketError(error) {
+    // ignore, the close handler takes care of retry
+  }
+
+  _onParserError(error) {
+    this._retry();
+  }
+
+  _retry() {
+    this._destroy();
+    const timeout = Math.min(++this._retryCount, MAX_RETRY_TIMEOUT) * 1000;
+    this._retryTimeout = setTimeout(this.connect.bind(this), timeout);
+  }
+
+  _onMessage({ tag, object }) {
+    if (tag === kLoginResponseTag) {
+      // clear persistent ids, as we just sent them to the server while logging
+      // in
+      this._persistentIds = [];
+    } else if (tag === kDataMessageStanzaTag) {
+      this._onDataMessage(object);
+    }
+  }
+
+  _onDataMessage(object) {
+    if (this._persistentIds.includes(object.persistentId)) {
+      return;
+    }
+
+    // if crypto keys not provided, notification is probably not encrypted, so return message as is
+    if(!("crypto-key" in object.appData)){
+        this._persistentIds.push(object.persistentId);
+        this.emit('ON_DATA_RECEIVED', object);
+        return;
+    }
+
+    let message;
+    try {
+
+      // decrypt message
+      message = decrypt(object, keys);
+
+    } catch (error) {
+      switch (true) {
+        case error.message.includes(
+          'Unsupported state or unable to authenticate data'
+        ):
+        case error.message.includes('crypto-key is missing'):
+        case error.message.includes('salt is missing'):
+          // NOTE(ibash) Periodically we're unable to decrypt notifications. In
+          // all cases we've been able to receive future notifications using the
+          // same keys. So, we silently drop this notification.
+          console.warn(
+            'Message dropped as it could not be decrypted: ' + error.message
+          );
+          this._persistentIds.push(object.persistentId);
+          return;
+        default: {
+          throw error;
+        }
+      }
+    }
+
+    // Maintain persistentIds updated with the very last received value
+    this._persistentIds.push(object.persistentId);
+    // Send notification
+    this.emit('ON_NOTIFICATION_RECEIVED', {
+      notification : message,
+      persistentId : object.persistentId,
+      object       : object,
+    });
+  }
+};

package/vendor/push-receiver/constants.js

@@ -0,0 +1,53 @@
+module.exports = {
+  // enum ProcessingState
+  //
+  // Processing the version, tag, and size packets (assuming minimum length
+  // size packet). Only used during the login handshake.
+  MCS_VERSION_TAG_AND_SIZE : 0,
+  // Processing the tag and size packets (assuming minimum length size
+  // packet). Used for normal messages.
+  MCS_TAG_AND_SIZE         : 1,
+  // Processing the size packet alone.
+  MCS_SIZE                 : 2,
+  // Processing the protocol buffer bytes (for those messages with non-zero
+  // sizes).
+  MCS_PROTO_BYTES          : 3,
+
+  // # of bytes a MCS version packet consumes.
+  kVersionPacketLen : 1,
+  // # of bytes a tag packet consumes.
+  kTagPacketLen     : 1,
+  // Max # of bytes a length packet consumes. A Varint32 can consume up to 5 bytes
+  // (the msb in each byte is reserved for denoting whether more bytes follow).
+  // Although the protocol only allows for 4KiB payloads currently, and the socket
+  // stream buffer is only of size 8KiB, it's possible for certain applications to
+  // have larger message sizes. When payload is larger than 4KiB, an temporary
+  // in-memory buffer is used instead of the normal in-place socket stream buffer.
+  kSizePacketLenMin : 1,
+  kSizePacketLenMax : 5,
+
+  // The current MCS protocol version.
+  kMCSVersion : 41,
+
+  // MCS Message tags.
+  // WARNING: the order of these tags must remain the same, as the tag values
+  // must be consistent with those used on the server.
+  // enum MCSProtoTag {
+  kHeartbeatPingTag       : 0,
+  kHeartbeatAckTag        : 1,
+  kLoginRequestTag        : 2,
+  kLoginResponseTag       : 3,
+  kCloseTag               : 4,
+  kMessageStanzaTag       : 5,
+  kPresenceStanzaTag      : 6,
+  kIqStanzaTag            : 7,
+  kDataMessageStanzaTag   : 8,
+  kBatchPresenceStanzaTag : 9,
+  kStreamErrorStanzaTag   : 10,
+  kHttpRequestTag         : 11,
+  kHttpResponseTag        : 12,
+  kBindAccountRequestTag  : 13,
+  kBindAccountResponseTag : 14,
+  kTalkMetadataTag        : 15,
+  kNumProtoTypes          : 16,
+};

package/vendor/push-receiver/fcm/index.js

@@ -0,0 +1,52 @@
+const crypto = require('crypto');
+const request = require('../utils/http-request');
+const { escape } = require('../utils/base64');
+
+const FCM_SUBSCRIBE = 'https://fcm.googleapis.com/fcm/connect/subscribe';
+const FCM_ENDPOINT = 'https://fcm.googleapis.com/fcm/send';
+
+module.exports = registerFCM;
+
+async function registerFCM({ senderId, token }) {
+  const keys = await createKeys();
+  const response = await request({
+    url     : FCM_SUBSCRIBE,
+    method  : 'POST',
+    headers : {
+      'Content-Type' : 'application/x-www-form-urlencoded',
+    },
+    form : {
+      authorized_entity : senderId,
+      endpoint          : `${FCM_ENDPOINT}/${token}`,
+      encryption_key    : keys.publicKey
+        .replace(/=/g, '')
+        .replace(/\+/g, '-')
+        .replace(/\//g, '_'),
+      encryption_auth : keys.authSecret
+        .replace(/=/g, '')
+        .replace(/\+/g, '-')
+        .replace(/\//g, '_'),
+    },
+  });
+  return {
+    keys,
+    fcm : JSON.parse(response),
+  };
+}
+
+function createKeys() {
+  return new Promise((resolve, reject) => {
+    const dh = crypto.createECDH('prime256v1');
+    dh.generateKeys();
+    crypto.randomBytes(16, (err, buf) => {
+      if (err) {
+        return reject(err);
+      }
+      return resolve({
+        privateKey : escape(dh.getPrivateKey('base64')),
+        publicKey  : escape(dh.getPublicKey('base64')),
+        authSecret : escape(buf.toString('base64')),
+      });
+    });
+  });
+}

package/vendor/push-receiver/fcm/server-key/index.js

@@ -0,0 +1,67 @@
+module.exports = [
+  0x04,
+  0x33,
+  0x94,
+  0xf7,
+  0xdf,
+  0xa1,
+  0xeb,
+  0xb1,
+  0xdc,
+  0x03,
+  0xa2,
+  0x5e,
+  0x15,
+  0x71,
+  0xdb,
+  0x48,
+  0xd3,
+  0x2e,
+  0xed,
+  0xed,
+  0xb2,
+  0x34,
+  0xdb,
+  0xb7,
+  0x47,
+  0x3a,
+  0x0c,
+  0x8f,
+  0xc4,
+  0xcc,
+  0xe1,
+  0x6f,
+  0x3c,
+  0x8c,
+  0x84,
+  0xdf,
+  0xab,
+  0xb6,
+  0x66,
+  0x3e,
+  0xf2,
+  0x0c,
+  0xd4,
+  0x8b,
+  0xfe,
+  0xe3,
+  0xf9,
+  0x76,
+  0x2f,
+  0x14,
+  0x1c,
+  0x63,
+  0x08,
+  0x6a,
+  0x6f,
+  0x2d,
+  0xb1,
+  0x1a,
+  0x95,
+  0xb0,
+  0xce,
+  0x37,
+  0xc0,
+  0x9c,
+  0x6e,
+];

package/vendor/push-receiver/gcm/android_checkin.proto

@@ -0,0 +1,96 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// Logging information for Android "checkin" events (automatic, periodic
+// requests made by Android devices to the server).
+
+syntax = "proto2";
+
+option optimize_for = LITE_RUNTIME;
+package checkin_proto;
+
+// Build characteristics unique to the Chrome browser, and Chrome OS
+message ChromeBuildProto {
+  enum Platform {
+    PLATFORM_WIN = 1;
+    PLATFORM_MAC = 2;
+    PLATFORM_LINUX = 3;
+    PLATFORM_CROS = 4;
+    PLATFORM_IOS = 5;
+    // Just a placeholder. Likely don't need it due to the presence of the
+    // Android GCM on phone/tablet devices.
+    PLATFORM_ANDROID = 6;
+  }
+
+  enum Channel {
+    CHANNEL_STABLE = 1;
+    CHANNEL_BETA = 2;
+    CHANNEL_DEV = 3;
+    CHANNEL_CANARY = 4;
+    CHANNEL_UNKNOWN = 5;  // for tip of tree or custom builds
+  }
+
+  // The platform of the device.
+  optional Platform platform = 1;
+
+  // The Chrome instance's version.
+  optional string chrome_version = 2;
+
+  // The Channel (build type) of Chrome.
+  optional Channel channel = 3;
+}
+
+// Information sent by the device in a "checkin" request.
+message AndroidCheckinProto {
+  // Miliseconds since the Unix epoch of the device's last successful checkin.
+  optional int64 last_checkin_msec = 2;
+
+  // The current MCC+MNC of the mobile device's current cell.
+  optional string cell_operator = 6;
+
+  // The MCC+MNC of the SIM card (different from operator if the
+  // device is roaming, for instance).
+  optional string sim_operator = 7;
+
+  // The device's current roaming state (reported starting in eclair builds).
+  // Currently one of "{,not}mobile-{,not}roaming", if it is present at all.
+  optional string roaming = 8;
+
+  // For devices supporting multiple user profiles (which may be
+  // supported starting in jellybean), the ordinal number of the
+  // profile that is checking in.  This is 0 for the primary profile
+  // (which can't be changed without wiping the device), and 1,2,3,...
+  // for additional profiles (which can be added and deleted freely).
+  optional int32 user_number = 9;
+
+  // Class of device.  Indicates the type of build proto
+  // (IosBuildProto/ChromeBuildProto/AndroidBuildProto)
+  // That is included in this proto
+  optional DeviceType type = 12 [default = DEVICE_ANDROID_OS];
+
+  // For devices running MCS on Chrome, build-specific characteristics
+  // of the browser.  There are no hardware aspects (except for ChromeOS).
+  // This will only be populated for Chrome builds/ChromeOS devices
+  optional checkin_proto.ChromeBuildProto chrome_build = 13;
+
+  // Note: Some of the Android specific optional fields were skipped to limit
+  // the protobuf definition.
+  // Next 14
+}
+
+// enum values correspond to the type of device.
+// Used in the AndroidCheckinProto and Device proto.
+enum DeviceType {
+  // Android Device
+  DEVICE_ANDROID_OS = 1;
+
+  // Apple IOS device
+  DEVICE_IOS_OS = 2;
+
+  // Chrome browser - Not Chrome OS.  No hardware records.
+  DEVICE_CHROME_BROWSER = 3;
+
+  // Chrome OS
+  DEVICE_CHROME_OS = 4;
+}

package/vendor/push-receiver/gcm/checkin.proto

@@ -0,0 +1,155 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// Request and reply to the "checkin server" devices poll every few hours.
+
+syntax = "proto2";
+
+option optimize_for = LITE_RUNTIME;
+
+package checkin_proto;
+
+import "android_checkin.proto";
+
+// A concrete name/value pair sent to the device's Gservices database.
+message GservicesSetting {
+  required bytes name = 1;
+  required bytes value = 2;
+}
+
+// Devices send this every few hours to tell us how they're doing.
+message AndroidCheckinRequest {
+  // IMEI (used by GSM phones) is sent and stored as 15 decimal
+  // digits; the 15th is a check digit.
+  optional string imei = 1;       // IMEI, reported but not logged.
+
+  // MEID (used by CDMA phones) is sent and stored as 14 hexadecimal
+  // digits (no check digit).
+  optional string meid = 10;      // MEID, reported but not logged.
+
+  // MAC address (used by non-phone devices).  12 hexadecimal digits;
+  // no separators (eg "0016E6513AC2", not "00:16:E6:51:3A:C2").
+  repeated string mac_addr = 9;   // MAC address, reported but not logged.
+
+  // An array parallel to mac_addr, describing the type of interface.
+  // Currently accepted values: "wifi", "ethernet", "bluetooth".  If
+  // not present, "wifi" is assumed.
+  repeated string mac_addr_type = 19;
+
+  // Serial number (a manufacturer-defined unique hardware
+  // identifier).  Alphanumeric, case-insensitive.
+  optional string serial_number = 16;
+
+  // Older CDMA networks use an ESN (8 hex digits) instead of an MEID.
+  optional string esn = 17;       // ESN, reported but not logged
+
+  optional int64 id = 2;          // Android device ID, not logged
+  optional int64 logging_id = 7;  // Pseudonymous logging ID for Sawmill
+  optional string digest = 3;     // Digest of device provisioning, not logged.
+  optional string locale = 6;     // Current locale in standard (xx_XX) format
+  required AndroidCheckinProto checkin = 4;
+
+  // DEPRECATED, see AndroidCheckinProto.requested_group
+  optional string desired_build = 5;
+
+  // Blob of data from the Market app to be passed to Market API server
+  optional string market_checkin = 8;
+
+  // SID cookies of any google accounts stored on the phone.  Not logged.
+  repeated string account_cookie = 11;
+
+  // Time zone.  Not currently logged.
+  optional string time_zone = 12;
+
+  // Security token used to validate the checkin request.
+  // Required for android IDs issued to Froyo+ devices, not for legacy IDs.
+  optional fixed64 security_token = 13;
+
+  // Version of checkin protocol.
+  //
+  // There are currently two versions:
+  //
+  // - version field missing: android IDs are assigned based on
+  //   hardware identifiers.  unsecured in the sense that you can
+  //   "unregister" someone's phone by sending a registration request
+  //   with their IMEI/MEID/MAC.
+  //
+  // - version=2: android IDs are assigned randomly.  The device is
+  //   sent a security token that must be included in all future
+  //   checkins for that android id.
+  //
+  // - version=3: same as version 2, but the 'fragment' field is
+  //   provided, and the device understands incremental updates to the
+  //   gservices table (ie, only returning the keys whose values have
+  //   changed.)
+  //
+  // (version=1 was skipped to avoid confusion with the "missing"
+  // version field that is effectively version 1.)
+  optional int32 version = 14;
+
+  // OTA certs accepted by device (base-64 SHA-1 of cert files).  Not
+  // logged.
+  repeated string ota_cert = 15;
+
+  // Honeycomb and newer devices send configuration data with their checkin.
+  // optional DeviceConfigurationProto device_configuration = 18;
+
+  // A single CheckinTask on the device may lead to multiple checkin
+  // requests if there is too much log data to upload in a single
+  // request.  For version 3 and up, this field will be filled in with
+  // the number of the request, starting with 0.
+  optional int32 fragment = 20;
+
+  // For devices supporting multiple users, the name of the current
+  // profile (they all check in independently, just as if they were
+  // multiple physical devices).  This may not be set, even if the
+  // device is using multiuser.  (checkin.user_number should be set to
+  // the ordinal of the user.)
+  optional string user_name = 21;
+
+  // For devices supporting multiple user profiles, the serial number
+  // for the user checking in.  Not logged.  May not be set, even if
+  // the device supportes multiuser.  checkin.user_number is the
+  // ordinal of the user (0, 1, 2, ...), which may be reused if users
+  // are deleted and re-created.  user_serial_number is never reused
+  // (unless the device is wiped).
+  optional int32 user_serial_number = 22;
+
+  // NEXT TAG: 23
+}
+
+// The response to the device.
+message AndroidCheckinResponse {
+  required bool stats_ok = 1;    // Whether statistics were recorded properly.
+  optional int64 time_msec = 3;  // Time of day from server (Java epoch).
+  // repeated AndroidIntentProto intent = 2;
+
+  // Provisioning is sent if the request included an obsolete digest.
+  //
+  // For version <= 2, 'digest' contains the digest that should be
+  // sent back to the server on the next checkin, and 'setting'
+  // contains the entire gservices table (which replaces the entire
+  // current table on the device).
+  //
+  // for version >= 3, 'digest' will be absent.  If 'settings_diff'
+  // is false, then 'setting' contains the entire table, as in version
+  // 2.  If 'settings_diff' is true, then 'delete_setting' contains
+  // the keys to delete, and 'setting' contains only keys to be added
+  // or for which the value has changed.  All other keys in the
+  // current table should be left untouched.  If 'settings_diff' is
+  // absent, don't touch the existing gservices table.
+  //
+  optional string digest = 4;
+  optional bool settings_diff = 9;
+  repeated string delete_setting = 10;
+  repeated GservicesSetting setting = 5;
+
+  optional bool market_ok = 6;   // If Market got the market_checkin data OK.
+
+  optional fixed64 android_id = 7;      // From the request, or newly assigned
+  optional fixed64 security_token = 8;  // The associated security token
+
+  optional string version_info = 11;
+  // NEXT TAG: 12
+}