whatsapp-nodejs 0.0.1-security → 0.0.1

package/src/lib/SocketProxy.js

@@ -0,0 +1,225 @@
+const net = require('net');
+
+const numberToHex = num => {
+  return Number(`0x${Number(num).toString(16)}`);
+};
+const ERROR_MAP = {
+  1: '代理服务器故障',
+  2: '代理服务器规则集不允许连接',
+  3: '网络无法访问',
+  4: '目标服务器无法访问（主机名无效）',
+  5: '连接目标服务器被拒绝',
+  6: 'TTL已过期',
+  7: '不支持的命令',
+  8: '不支持的目标服务器地址类型',
+};
+
+class Socket extends net.Socket {
+  constructor(opts = {}) {
+    super(opts);
+    const { proxy = {} } = opts;
+    const { port = 1080, host = '', username = '', password = '', type = 'socks5' } = proxy;
+    if (username && !password) throw new Error('You need to pass the password params.');
+    this.proxy = proxy;
+    this.proxyHost = host;
+    this.proxyPort = port;
+    this.proxyUsername = username;
+    this.proxyPassword = password;
+    this.proxyType = type;
+    if (!['socks5', 'http'].includes(type)) throw new Error(`Not support proxy type: ${type}`);
+    this.isConnected = false;
+
+    const _on = this.on;
+    this._on = _on;
+
+    this.on = (name, listener) => {
+      const isTmp = !!name.match('_tmp');
+      _on.call(this, name.replace('_tmp', ''), (...args) => {
+        if (this.isConnected) {
+          listener.apply(this, args);
+        } else if (isTmp) {
+          listener.apply(this, args);
+        } else if (name === 'connect') {
+          listener.apply(this, args);
+        }
+      });
+    };
+  }
+
+  async connect(opts = {}, listener) {
+    if (this.proxyType === 'socks5') {
+      await this.connectSocks(opts, listener);
+    } else {
+      await this.connnectHttp(opts, listener);
+    }
+    this.on = this._on;
+    this.isConnected = true;
+    console.log('Socket proxy connect success.');
+  }
+
+  async connnectHttp(opts = {}, listener) {
+    const targetHost = opts.host;
+    const targetPort = opts.port;
+
+    return new Promise((resolve, reject) => {
+      console.debug(
+        'Start connect target: ',
+        `${this.proxyType}://${this.proxyPort}:${this.proxyHost}`,
+        this.proxyUsername,
+        this.proxyPassword
+      );
+      super.connect({
+        port: this.proxyPort,
+        host: this.proxyHost,
+      });
+      this.once('connect_tmp', () => {
+        console.debug('Send Connect method.');
+        this.write(`CONNECT ${targetHost}:${targetPort} HTTP/1.1\r\n`);
+        this.write('Connection: keep-alive\r\n');
+        this.write('Content-Length: 0\r\n');
+        if (this.proxyUsername) {
+          const base64 = Buffer.from(`${this.proxyUsername}:${this.proxyPassword}`).toString(
+            'base64'
+          );
+          this.write(`Proxy-Authorization: Basic ${base64}\r\n`);
+        }
+        this.write('\r\n');
+        this.once('data_tmp', data => {
+          const str = String(data.toString()).trim();
+          console.debug(`Recv Connect method: ${str}`);
+          if (!str.match(/^HTTP\/1\.1 200/i)) {
+            return reject(new Error(str));
+          }
+          if (typeof listener === 'function') listener();
+          console.debug('Connnect socket success.');
+          resolve();
+        });
+      });
+    });
+  }
+
+  async connectSocks(opts = {}, listener) {
+    const host = this.proxyHost || opts.host;
+    const port = this.proxyPort || opts.port;
+    const params = { ...opts, host, port };
+
+    return new Promise((resolve, reject) => {
+      if (this.proxyHost) {
+        console.debug('Start connect proxy: ', `${this.proxyType}://${host}:${port}`);
+      } else {
+        console.debug('Start connect target: ', `${host}:${port}`);
+      }
+      super.connect(params);
+      this.once('connect_tmp', async () => {
+        if (this.proxyHost) {
+          console.debug(`Connect proxy success:`, ` ${this.proxyType}://${host}:${port}`);
+        } else {
+          console.debug('Connect target success: ', `${host}:${port}`);
+        }
+        try {
+          await this.auth();
+          await this.connectTarget(opts);
+          if (typeof listener === 'function') listener();
+          resolve();
+        } catch (e) {
+          reject(e);
+        }
+      });
+    });
+  }
+
+  async auth() {
+    if (!this.proxyHost) return; // 不需要代理
+    /** 第一位 socks 版本，固定 0x05
+    // 第二位，支持的验证方法数量，默认支持无密码和有密码两种
+    // 第三第四位，
+    0x00 不需要认证（常用）
+    0x01 GSSAPI认证
+    0x02 账号密码认证（常用）
+    0x03 - 0x7F IANA分配
+    0x80 - 0xFE 私有方法保留
+    0xFF 无支持的认证方法
+    */
+    return new Promise((resolve, reject) => {
+      const head = Buffer.from([0x05, 0x02, 0x00, 0x02]);
+      this.write(head);
+      this.once('data_tmp', data => {
+        if (data.length !== 2) {
+          return reject(new Error('Unexpected number of bytes received.'));
+        }
+        if (data[0] !== 0x05) {
+          return reject(new Error(`Unexpected socks version number: ${data[0]}.`));
+        }
+        const authType = data[1];
+        if (authType !== 0x00 && authType !== 0x02)
+          return reject(new Error(`Unexpected socks authentication method: ${authType}`));
+        if (authType === 0x00) {
+          console.debug('Not need auth.');
+          return resolve();
+        }
+        console.debug('Use auth: ', this.proxyUsername, this.proxyPassword);
+        const bUsername = Buffer.from(this.proxyUsername);
+        let bUser = Buffer.concat([Buffer.from([0x01, bUsername.length]), bUsername]);
+        const bPassword = Buffer.from(this.proxyPassword);
+        bUser = Buffer.concat([bUser, Buffer.from([bPassword.length]), bPassword]);
+        this.write(bUser);
+
+        this.once('data_tmp', authData => {
+          if (authData.length !== 2)
+            return reject(new Error('Unexpected number of bytes received.'));
+          if (authData[0] !== 0x01)
+            return reject(new Error(`Unexpected authentication method code: ${authData[0]}.`));
+          if (authData[1] !== 0x00)
+            return reject(
+              new Error(`Username and password authentication failure: ${authData[1]}.`)
+            );
+          resolve();
+        });
+      });
+    });
+  }
+
+  async connectTarget(opts = {}) {
+    if (!this.proxyHost) return; // 不需要代理
+    const { host, port } = opts;
+    return new Promise((resolve, reject) => {
+      let buffer = Buffer.from([0x05, 0x01, 0x00]);
+      const targetType = net.isIP(host);
+      let hexPort = Number(port).toString(16);
+      if (hexPort.length < 4) {
+        hexPort = new Array(4 - hexPort.length + 1).join('0') + hexPort;
+      }
+      if (targetType === 4) {
+        buffer = Buffer.concat([
+          buffer,
+          Buffer.from([0x01]),
+          Buffer.from(host.split('.').map(num => numberToHex(num))),
+          Buffer.from([Number(`0x${hexPort.substr(0, 2)}`), Number(`0x${hexPort.substr(2)}`)]),
+        ]);
+      } else if (targetType === 0) {
+        const bufferHost = Buffer.from(host);
+        buffer = Buffer.concat([
+          buffer,
+          Buffer.from([0x03, bufferHost.length]),
+          bufferHost,
+          Buffer.from([Number(`0x${hexPort.substr(0, 2)}`), Number(`0x${hexPort.substr(2)}`)]),
+        ]);
+      }
+      console.debug('Connnect socket target: ', `${host}:${port}`);
+      this.write(buffer);
+      this.once('data_tmp', data => {
+        const version = data[0];
+        if (version !== 0x05)
+          return reject(new Error(`Unexpected SOCKS version number: ${version}.`));
+        const response = data[1];
+        if (response !== 0x00) {
+          if (ERROR_MAP[response]) return reject(new Error(ERROR_MAP[response]));
+          return reject(new Error('Unknown error'));
+        }
+        resolve();
+      });
+    });
+  }
+}
+
+module.exports = Socket;

package/src/lib/libsignal-protocol.js

@@ -0,0 +1,14 @@
+const crypto = require('crypto');
+
+global.window = {};
+class XMLHttpRequest {}
+global.XMLHttpRequest = XMLHttpRequest;
+const libsignal = require('@privacyresearch/libsignal-protocol-typescript');
+
+crypto.getRandomValues = array => {
+  const size = array.length;
+  return crypto.randomBytes(size);
+};
+// libsignal.setWebCrypto(crypto)
+
+module.exports = libsignal;

package/src/lib/utils.js

@@ -0,0 +1,123 @@
+const { v4 } = require('uuid');
+const { SocksProxyAgent } = require('socks-proxy-agent');
+const tunnel = require('tunnel');
+
+const uuidv4 = v4;
+const crypto = require('crypto');
+const libsignal = require('./libsignal-protocol');
+
+module.exports = {
+  KEY_SIZE: 32,
+  fillZero(str, len) {
+    if (len && str.length < len) {
+      str = new Array(len - str.length + 1).join('0') + str;
+    }
+    return str;
+  },
+  getHttpsProxyAgent(proxy) {
+    const proxyConfig = {
+      host: proxy.host,
+      port: proxy.port,
+    };
+    // http 代理
+    if (proxy.type === 'http') {
+      if (proxy.userId) {
+        proxyConfig.proxyAuth = `${proxy.userId}:${proxy.password}`;
+      }
+      const agent = tunnel.httpsOverHttp({
+        proxy: proxyConfig,
+      });
+      return agent;
+    }
+    // socks5 代理
+    if (proxy.userId) {
+      proxyConfig.userId = proxy.userId;
+      proxyConfig.password = proxy.password;
+    }
+    const agent = new SocksProxyAgent(proxyConfig);
+    return agent;
+  },
+  async sleep(t) {
+    return new Promise(resolve => {
+      setTimeout(resolve, t);
+    });
+  },
+  toString(thing) {
+    if (typeof thing === 'string') return thing;
+    return thing.toString('base64');
+  },
+  toBuffer(plaintext) {
+    return typeof plaintext === 'string'
+      ? Buffer.from(plaintext, 'base64')
+      : Buffer.from(plaintext);
+  },
+  normalize(number) {
+    if (String(number).indexOf('@') !== -1) return number;
+    if (String(number).indexOf('-') !== -1) return `${number}@g.us`;
+    return `${String(number)}@s.whatsapp.net`;
+  },
+  generateHeader(num, len = 6) {
+    let str = Number(num).toString(16);
+    str = new Array(len - str.length + 1).join('0') + str;
+    return Buffer.from(str, 'hex');
+  },
+  generateId(num = 0) {
+    let str = Number(num).toString(16);
+    if (str.length % 2 === 1) str = `0${str}`;
+    return str;
+  },
+  generateUUID() {
+    return uuidv4();
+  },
+  urandom(len) {
+    return crypto.randomBytes(len);
+  },
+  generateIdentity() {
+    return this.urandom(20);
+  },
+  generateSenderKey() {
+    return this.urandom(32);
+  },
+  generateSenderKeyId() {
+    return Math.floor(Math.random() * 2147483647);
+  },
+  generatePhoneId() {
+    return this.generateUUID();
+  },
+  generateDeviceId() {
+    return Buffer.from(this.generateUUID().replace(/-/g, ''), 'hex');
+  },
+  generateKeyPair() {
+    const keyPair = libsignal.curve.generateKeyPair();
+    keyPair.pubKey = Buffer.from(keyPair.pubKey);
+    keyPair.privKey = Buffer.from(keyPair.privKey);
+    return {
+      public: keyPair.pubKey.slice(keyPair.pubKey.length - this.KEY_SIZE),
+      private: keyPair.privKey.slice(keyPair.privKey.length - this.KEY_SIZE),
+    };
+  },
+  generateSenderSigningKey() {
+    return this.generateKeyPair();
+  },
+  hash(message, type = 'md5', encode = 'base64') {
+    // crypto.createHash('sha256').update(m).digest('base64')
+    return crypto
+      .createHash(type)
+      .update(message)
+      .digest(encode);
+  },
+  hmacHash(key, message, type = 'sha256', encode = 'base64') {
+    const hmac = crypto.createHmac(type, key);
+    hmac.update(message);
+    return hmac.digest(encode); // kXogg18q...
+  },
+  bufferToArrayBuffer(buffer) {
+    if (!buffer) buffer = Buffer.alloc(0);
+    const arrayBuffer = new ArrayBuffer(buffer.length);
+    const uint8Array = new Uint8Array(arrayBuffer);
+    buffer.forEach((val, i) => {
+      uint8Array[i] = val;
+    });
+    return arrayBuffer;
+  },
+};

package/src/logger.js

@@ -0,0 +1,79 @@
+const bunyan = require('bunyan');
+const bunyanDebugStream = require('bunyan-debug-stream');
+const path = require('path');
+const fse = require('fs-extra');
+const os = require('os');
+
+const env = process.env.NODE_ENV;
+const isProduction = env === 'production' && os.platform() !== 'darwin';
+
+let logDir = path.join(__dirname, '../logs/');
+
+if (isProduction) {
+  logDir = `/root/logs/`;
+}
+
+fse.ensureDirSync(logDir);
+
+const debugStream = {
+  level: 'debug',
+  type: 'raw',
+  stream: bunyanDebugStream({
+    forceColor: true,
+  }),
+};
+
+const debugFileStream = {
+  level: 'debug',
+  type: 'rotating-file',
+  path: path.join(logDir, `whatsapp.debug.log`),
+  period: '1d',
+  count: 7,
+};
+
+const errorFileStream = {
+  level: 'error',
+  type: 'rotating-file',
+  path: path.join(logDir, `whatsapp.error.log`),
+  period: '1d',
+  count: 7,
+};
+
+const fatalFileStream = {
+  level: 'fatal',
+  type: 'rotating-file',
+  path: path.join(logDir, `whatsapp.fatal.log`),
+  period: '1d',
+  count: 7,
+};
+
+const streams = [];
+
+if (isProduction) {
+  streams.push(errorFileStream);
+} else {
+  streams.push(debugStream);
+  streams.push(debugFileStream);
+  streams.push(errorFileStream);
+  streams.push(fatalFileStream);
+}
+
+const logger = bunyan.createLogger({
+  name: 'WA',
+  streams,
+});
+
+['fatal', 'error', 'warn', 'info', 'debug', 'trace', 'child'].forEach(method => {
+  // eslint-disable-next-line
+  global.console[method] = function() {
+    // eslint-disable-next-line
+    return logger[method].apply(logger, arguments);
+  };
+});
+// eslint-disable-next-line
+console.log = function() {
+  // eslint-disable-next-line
+  logger.info.apply(logger, arguments);
+};
+
+module.exports = logger;

package/src/packet/ProtocolEntity.js

@@ -0,0 +1,39 @@
+const ProtocolTreeNode = require('./ProtocolTreeNode');
+
+class ProtocolEntity {
+  constructor(tag, attrs, children = [], data = null) {
+    this.tag = tag;
+    this.attrs = attrs;
+    this.children = children;
+    this.data = data;
+  }
+
+  getTag() {
+    return this.tag;
+  }
+
+  isType(typ) {
+    return this.tag === typ;
+  }
+
+  _createProtocolTreeNode(attributes, children = null, data = null) {
+    return new ProtocolTreeNode(this.getTag(), attributes, children, data);
+  }
+
+  _getCurrentTimestamp() {
+    return Math.round(Date.now() / 1000);
+  }
+
+  _generateId(short = false) {
+    return short ? 'short' : `long`;
+  }
+
+  // eslint-disable-next-line
+  toTreeNode() {
+    return this._createProtocolTreeNode(this.attrs, this.children, this.data);
+  }
+  // eslint-disable-next-line
+  static fromTreeNode(protocolTreeNode) {}
+}
+
+module.exports = ProtocolEntity;

package/src/packet/ProtocolTreeNode.js

@@ -0,0 +1,202 @@
+const WriteEncoder = require('../bin/encoder');
+
+class ProtocolTreeNode {
+  constructor(tag, attributes = null, children = null, data = null) {
+    this.tag = tag;
+    this.attributes = attributes || {};
+    this.children = children || [];
+    this.data = data;
+    Object.keys(this.attributes).forEach(key => {
+      if (this.attributes[key] === undefined || this.attributes[key] === null) {
+        delete this.attributes[key];
+      }
+    });
+    this.children = this.children.map(child => {
+      return new ProtocolTreeNode(child.tag, child.attributes, child.children, child.data);
+    });
+  }
+
+  toBuffer() {
+    try {
+      const bytes = new WriteEncoder().protocolTreeNodeToBytes(this);
+      return Buffer.from(bytes);
+    } catch (e) {
+      console.error(`Node 序列化 buffer 失败`, e);
+    }
+  }
+
+  toString() {
+    let out = `<${this.tag}`;
+    if (this.attributes) {
+      Object.keys(this.attributes).forEach(key => {
+        const val = this.attributes[key];
+        out += ` ${key}="${val}"`;
+      });
+    }
+    out += '>\n';
+    if (this.data) {
+      if (this.data instanceof Buffer) {
+        out += this.data.toString('utf8');
+      } else {
+        try {
+          out += this.data;
+        } catch (e) {
+          try {
+            out += this.data.toString();
+          } catch (err) {
+            out += this.data.toString('hex');
+          }
+        }
+      }
+      out += `\nHEX3:${Buffer.from(this.data || '').toString('hex')}\n`;
+    }
+
+    for (let i = 0; i < this.children.length; i++) {
+      const c = this.children[i];
+      try {
+        out += c.toString();
+      } catch (e) {
+        console.error(e);
+        out += '[ENCODED DATA]\n';
+      }
+    }
+    out += `</${this.tag}>\n`;
+    return out;
+  }
+
+  toJSON() {
+    const json = {
+      tag: this.tag,
+      props: this.attributes,
+      children: [],
+    };
+    Object.keys(this.attributes).forEach(key => {
+      let value = this.attributes[key];
+      if (value instanceof Buffer) {
+        value = value.toString('utf8');
+        this.attributes[key] = value;
+      }
+    });
+    if (this.data !== null) {
+      json.data = this.data;
+      // if (json.data instanceof Buffer) {
+      //   json.data = json.data.toString('utf8');
+      // }
+    }
+    for (let i = 0; i < this.children.length; i++) {
+      const c = this.children[i];
+      try {
+        json.children.push(c.toJSON());
+      } catch (e) {
+        console.error(e);
+        json.children.push('[ENCODED DATA]');
+      }
+    }
+    return json;
+  }
+
+  toSimpleJSON() {
+    const json = {};
+    json[this.tag] = {};
+    Object.keys(this.attributes).forEach(key => {
+      let value = this.attributes[key];
+      if (value instanceof Buffer) {
+        value = value.toString('utf8');
+      }
+      json[this.tag][key] = value;
+    });
+    try {
+      for (let i = 0; i < this.children.length; i++) {
+        const c = this.children[i].toSimpleJSON();
+        if (!c) continue;
+        let tag = Object.keys(c)[0];
+        const child = c[tag];
+        if (typeof this.attributes[tag] !== 'undefined') {
+          tag = `${tag}_entity`;
+        }
+        if (json[this.tag][tag]) {
+          if (Array.isArray(json[this.tag][tag])) {
+            json[this.tag][tag].push(child);
+          } else {
+            json[this.tag][tag] = [json[this.tag][tag], child];
+          }
+        } else {
+          json[this.tag][tag] = child;
+        }
+      }
+    } catch (e) {
+      console.error(e);
+    }
+    if (this.data !== null && typeof this.data !== 'undefined') {
+      json[this.tag].entity_value = this.data;
+      if (json[this.tag].entity_value instanceof Buffer) {
+        json[this.tag].entity_value = json[this.tag].entity_value.toString('utf8');
+      }
+    }
+    return json || {};
+  }
+
+  setData(data) {
+    this.data = data;
+  }
+
+  getData() {
+    return this.data;
+  }
+
+  getChild(identifier) {
+    if (typeof identifier === 'number') {
+      if (this.children.length > identifier) return this.children[identifier];
+      return null;
+    }
+    for (let i = 0; i < this.children.length; i++) {
+      const c = this.children[i];
+      if (c.tag === identifier) return c;
+    }
+    return null;
+  }
+
+  addChild(childNode) {
+    this.children.push(childNode);
+  }
+
+  addChildren(children) {
+    children.forEach(child => {
+      this.addChild(child);
+    });
+  }
+
+  hasChildren() {
+    return this.children.length > 0;
+  }
+
+  getAllChildren(tag = null) {
+    if (!tag) return this.children;
+    return this.children.filter(child => child.tag === tag);
+  }
+
+  getAttributeValue(key) {
+    return this.attributes[key];
+  }
+
+  getAttr(key) {
+    return this.getAttributeValue(key);
+  }
+
+  setAttr(key, value) {
+    this.setAttribute(key, value);
+  }
+
+  removeAttr(key) {
+    delete this.attributes[key];
+  }
+
+  removeAttribute(key) {
+    delete this.attributes[key];
+  }
+
+  setAttribute(key, value) {
+    this.attributes[key] = value;
+  }
+}
+module.exports = ProtocolTreeNode;