@biggy1337/discord-sbjs 1.3.11

package/src/util/Permissions.js

@@ -0,0 +1,202 @@
+'use strict';
+
+const BitField = require('./BitField');
+
+/**
+ * Data structure that makes it easy to interact with a permission bitfield. All {@link GuildMember}s have a set of
+ * permissions in their guild, and each channel in the guild may also have {@link PermissionOverwrites} for the member
+ * that override their default permissions.
+ * @extends {BitField}
+ */
+class Permissions extends BitField {
+  /**
+   * Bitfield of the packed bits
+   * @type {bigint}
+   * @name Permissions#bitfield
+   */
+
+  /**
+   * Data that can be resolved to give a permission number. This can be:
+   * * A string (see {@link Permissions.FLAGS})
+   * * A permission number
+   * * An instance of Permissions
+   * * An Array of PermissionResolvable
+   * @typedef {string|bigint|Permissions|PermissionResolvable[]} PermissionResolvable
+   */
+
+  /**
+   * Gets all given bits that are missing from the bitfield.
+   * @param {BitFieldResolvable} bits Bit(s) to check for
+   * @param {boolean} [checkAdmin=true] Whether to allow the administrator permission to override
+   * @returns {string[]}
+   */
+  missing(bits, checkAdmin = true) {
+    return checkAdmin && this.has(this.constructor.FLAGS.ADMINISTRATOR) ? [] : super.missing(bits);
+  }
+
+  /**
+   * Checks whether the bitfield has a permission, or any of multiple permissions.
+   * @param {PermissionResolvable} permission Permission(s) to check for
+   * @param {boolean} [checkAdmin=true] Whether to allow the administrator permission to override
+   * @returns {boolean}
+   */
+  any(permission, checkAdmin = true) {
+    return (checkAdmin && super.has(this.constructor.FLAGS.ADMINISTRATOR)) || super.any(permission);
+  }
+
+  /**
+   * Checks whether the bitfield has a permission, or multiple permissions.
+   * @param {PermissionResolvable} permission Permission(s) to check for
+   * @param {boolean} [checkAdmin=true] Whether to allow the administrator permission to override
+   * @returns {boolean}
+   */
+  has(permission, checkAdmin = true) {
+    return (checkAdmin && super.has(this.constructor.FLAGS.ADMINISTRATOR)) || super.has(permission);
+  }
+
+  /**
+   * Gets an {@link Array} of bitfield names based on the permissions available.
+   * @returns {string[]}
+   */
+  toArray() {
+    return super.toArray(false);
+  }
+}
+
+/**
+ * Numeric permission flags. All available properties:
+ * * `CREATE_INSTANT_INVITE` (create invitations to the guild)
+ * * `KICK_MEMBERS`
+ * * `BAN_MEMBERS`
+ * * `ADMINISTRATOR` (implicitly has *all* permissions, and bypasses all channel overwrites)
+ * * `MANAGE_CHANNELS` (edit and reorder channels)
+ * * `MANAGE_GUILD` (edit the guild information, region, etc.)
+ * * `ADD_REACTIONS` (add new reactions to messages)
+ * * `VIEW_AUDIT_LOG`
+ * * `PRIORITY_SPEAKER`
+ * * `STREAM`
+ * * `VIEW_CHANNEL`
+ * * `SEND_MESSAGES`
+ * * `SEND_TTS_MESSAGES`
+ * * `MANAGE_MESSAGES` (delete messages and reactions)
+ * * `EMBED_LINKS` (links posted will have a preview embedded)
+ * * `ATTACH_FILES`
+ * * `READ_MESSAGE_HISTORY` (view messages that were posted prior to opening Discord)
+ * * `MENTION_EVERYONE`
+ * * `USE_EXTERNAL_EMOJIS` (use emojis from different guilds)
+ * * `VIEW_GUILD_INSIGHTS`
+ * * `CONNECT` (connect to a voice channel)
+ * * `SPEAK` (speak in a voice channel)
+ * * `MUTE_MEMBERS` (mute members across all voice channels)
+ * * `DEAFEN_MEMBERS` (deafen members across all voice channels)
+ * * `MOVE_MEMBERS` (move members between voice channels)
+ * * `USE_VAD` (use voice activity detection)
+ * * `CHANGE_NICKNAME`
+ * * `MANAGE_NICKNAMES` (change other members' nicknames)
+ * * `MANAGE_ROLES`
+ * * `MANAGE_WEBHOOKS`
+ * * `MANAGE_EMOJIS_AND_STICKERS`
+ * * `USE_APPLICATION_COMMANDS`
+ * * `REQUEST_TO_SPEAK`
+ * * `MANAGE_EVENTS`
+ * * `MANAGE_THREADS`
+ * * `USE_PUBLIC_THREADS` (deprecated)
+ * * `CREATE_PUBLIC_THREADS`
+ * * `USE_PRIVATE_THREADS` (deprecated)
+ * * `CREATE_PRIVATE_THREADS`
+ * * `USE_EXTERNAL_STICKERS` (use stickers from different guilds)
+ * * `SEND_MESSAGES_IN_THREADS`
+ * * `START_EMBEDDED_ACTIVITIES`
+ * * `MODERATE_MEMBERS`
+ * * `VIEW_CREATOR_MONETIZATION_ANALYTICS`
+ * * `USE_SOUNDBOARD`
+ * * `CREATE_GUILD_EXPRESSIONS`
+ * * `CREATE_EVENTS`
+ * * `USE_EXTERNAL_SOUNDS`
+ * * `SEND_VOICE_MESSAGES`
+ * * `USE_CLYDE_AI`
+ * * `SET_VOICE_CHANNEL_STATUS`
+ * * `SEND_POLLS`
+ * * `USE_EXTERNAL_APPS`
+ * @type {Object<string, bigint>}
+ * @see {@link https://discord.com/developers/docs/topics/permissions#permissions-bitwise-permission-flags}
+ */
+Permissions.FLAGS = {
+  CREATE_INSTANT_INVITE: 1n << 0n,
+  KICK_MEMBERS: 1n << 1n,
+  BAN_MEMBERS: 1n << 2n,
+  ADMINISTRATOR: 1n << 3n,
+  MANAGE_CHANNELS: 1n << 4n,
+  MANAGE_GUILD: 1n << 5n,
+  ADD_REACTIONS: 1n << 6n,
+  VIEW_AUDIT_LOG: 1n << 7n,
+  PRIORITY_SPEAKER: 1n << 8n,
+  STREAM: 1n << 9n,
+  VIEW_CHANNEL: 1n << 10n,
+  SEND_MESSAGES: 1n << 11n,
+  SEND_TTS_MESSAGES: 1n << 12n,
+  MANAGE_MESSAGES: 1n << 13n,
+  EMBED_LINKS: 1n << 14n,
+  ATTACH_FILES: 1n << 15n,
+  READ_MESSAGE_HISTORY: 1n << 16n,
+  MENTION_EVERYONE: 1n << 17n,
+  USE_EXTERNAL_EMOJIS: 1n << 18n,
+  VIEW_GUILD_INSIGHTS: 1n << 19n,
+  CONNECT: 1n << 20n,
+  SPEAK: 1n << 21n,
+  MUTE_MEMBERS: 1n << 22n,
+  DEAFEN_MEMBERS: 1n << 23n,
+  MOVE_MEMBERS: 1n << 24n,
+  USE_VAD: 1n << 25n,
+  CHANGE_NICKNAME: 1n << 26n,
+  MANAGE_NICKNAMES: 1n << 27n,
+  MANAGE_ROLES: 1n << 28n,
+  MANAGE_WEBHOOKS: 1n << 29n,
+  MANAGE_EMOJIS_AND_STICKERS: 1n << 30n,
+  USE_APPLICATION_COMMANDS: 1n << 31n,
+  REQUEST_TO_SPEAK: 1n << 32n,
+  MANAGE_EVENTS: 1n << 33n,
+  MANAGE_THREADS: 1n << 34n,
+  // TODO: Remove deprecated USE_*_THREADS flags in v14
+  USE_PUBLIC_THREADS: 1n << 35n,
+  CREATE_PUBLIC_THREADS: 1n << 35n,
+  USE_PRIVATE_THREADS: 1n << 36n,
+  CREATE_PRIVATE_THREADS: 1n << 36n,
+  USE_EXTERNAL_STICKERS: 1n << 37n,
+  SEND_MESSAGES_IN_THREADS: 1n << 38n,
+  START_EMBEDDED_ACTIVITIES: 1n << 39n,
+  MODERATE_MEMBERS: 1n << 40n,
+  VIEW_CREATOR_MONETIZATION_ANALYTICS: 1n << 41n,
+  USE_SOUNDBOARD: 1n << 42n,
+  CREATE_GUILD_EXPRESSIONS: 1n << 43n,
+  CREATE_EVENTS: 1n << 44n,
+  USE_EXTERNAL_SOUNDS: 1n << 45n,
+  SEND_VOICE_MESSAGES: 1n << 46n,
+  USE_CLYDE_AI: 1n << 47n,
+  SET_VOICE_CHANNEL_STATUS: 1n << 48n,
+  SEND_POLLS: 1n << 49n,
+  USE_EXTERNAL_APPS: 1n << 50n,
+};
+
+/**
+ * Bitfield representing every permission combined
+ * @type {bigint}
+ */
+Permissions.ALL = Object.values(Permissions.FLAGS).reduce((all, p) => all | p, 0n);
+
+/**
+ * Bitfield representing the default permissions for users
+ * @type {bigint}
+ */
+Permissions.DEFAULT = BigInt(104324673);
+
+/**
+ * Bitfield representing the permissions required for moderators of stage channels
+ * @type {bigint}
+ */
+Permissions.STAGE_MODERATOR =
+  Permissions.FLAGS.MANAGE_CHANNELS | Permissions.FLAGS.MUTE_MEMBERS | Permissions.FLAGS.MOVE_MEMBERS;
+
+Permissions.defaultBit = BigInt(0);
+
+module.exports = Permissions;

package/src/util/PremiumUsageFlags.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const BitField = require('./BitField');
+
+/**
+ * Data structure that makes it easy to interact with an {@link PremiumUsageFlags#flags} bitfield.
+ * @extends {BitField}
+ */
+class PremiumUsageFlags extends BitField {}
+
+/**
+ * @name PremiumUsageFlags
+ * @kind constructor
+ * @memberof PremiumUsageFlags
+ * @param {BitFieldResolvable} [bits=0] Bit(s) to read from
+ */
+
+/**
+ * Numeric the Discord premium usage flags. All available properties:
+ * * `PREMIUM_DISCRIMINATOR`
+ * * `ANIMATED_AVATAR`
+ * * `PROFILE_BANNER`
+ * @type {Object}
+ */
+PremiumUsageFlags.FLAGS = {
+  PREMIUM_DISCRIMINATOR: 1 << 0,
+  ANIMATED_AVATAR: 1 << 1,
+  PROFILE_BANNER: 1 << 2,
+};
+
+module.exports = PremiumUsageFlags;

package/src/util/PurchasedFlags.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const BitField = require('./BitField');
+
+/**
+ * Data structure that makes it easy to interact with an {@link PurchasedFlags#flags} bitfield.
+ * @extends {BitField}
+ */
+class PurchasedFlags extends BitField {}
+
+/**
+ * @name PurchasedFlags
+ * @kind constructor
+ * @memberof PurchasedFlags
+ * @param {BitFieldResolvable} [bits=0] Bit(s) to read from
+ */
+
+/**
+ * Numeric the Discord purchased flags. All available properties:
+ * * `NITRO_CLASSIC`
+ * * `NITRO`
+ * * `GUILD_BOOST`
+ * * `NITRO_BASIC`
+ * @type {Object}
+ */
+PurchasedFlags.FLAGS = {
+  NITRO_CLASSIC: 1 << 0,
+  NITRO: 1 << 1,
+  GUILD_BOOST: 1 << 2,
+  NITRO_BASIC: 1 << 3,
+};
+
+module.exports = PurchasedFlags;

package/src/util/RemoteAuth.js

@@ -0,0 +1,425 @@
+'use strict';
+
+const { Buffer } = require('node:buffer');
+const crypto = require('node:crypto');
+const EventEmitter = require('node:events');
+const { setTimeout } = require('node:timers');
+const { UserAgent } = require('./Constants');
+const { getNativeFetch } = require('./FetchUtil');
+const Options = require('./Options');
+const { WebSocket } = require('../WebSocket');
+
+const fetch = getNativeFetch();
+
+const defaultClientOptions = Options.createDefault();
+const superPropertiesBase64 = Buffer.from(JSON.stringify(defaultClientOptions.ws.properties), 'ascii').toString(
+  'base64',
+);
+
+const baseURL = 'https://discord.com/ra/';
+
+const wsURL = 'wss://remote-auth-gateway.discord.gg/?v=2';
+
+const receiveEvent = {
+  HELLO: 'hello',
+  NONCE_PROOF: 'nonce_proof',
+  PENDING_REMOTE_INIT: 'pending_remote_init',
+  HEARTBEAT_ACK: 'heartbeat_ack',
+  PENDING_TICKET: 'pending_ticket',
+  CANCEL: 'cancel',
+  PENDING_LOGIN: 'pending_login',
+};
+
+const sendEvent = {
+  INIT: 'init',
+  NONCE_PROOF: 'nonce_proof',
+  HEARTBEAT: 'heartbeat',
+};
+
+const Event = {
+  READY: 'ready',
+  ERROR: 'error',
+  CANCEL: 'cancel',
+  WAIT_SCAN: 'pending',
+  FINISH: 'finish',
+  CLOSED: 'closed',
+  DEBUG: 'debug',
+};
+
+/**
+ * Discord Auth QR
+ * @extends {EventEmitter}
+ * @abstract
+ */
+class DiscordAuthWebsocket extends EventEmitter {
+  #ws = null;
+  #heartbeatTimeout = null;
+  #heartbeatInterval = null;
+  #expire = null;
+  #publicKey = null;
+  #privateKey = null;
+  #encodedPublicKey = null;
+  #ticket = null;
+  #fingerprint = '';
+  #userDecryptString = '';
+
+  /**
+   * Creates a new DiscordAuthWebsocket instance.
+   */
+  constructor() {
+    super();
+    this.token = '';
+  }
+
+  /**
+   * @type {string}
+   */
+  get AuthURL() {
+    return baseURL + this.#fingerprint;
+  }
+
+  /**
+   * @type {Date}
+   */
+  get expire() {
+    return this.#expire;
+  }
+
+  /**
+   * @type {Date}
+   * @deprecated Use {@link DiscordAuthWebsocket#expire} instead.
+   */
+  get exprire() {
+    return this.expire;
+  }
+
+  /**
+   * @type {UserRaw}
+   */
+  get user() {
+    return DiscordAuthWebsocket.decryptUser(this.#userDecryptString);
+  }
+
+  #createWebSocket(url) {
+    this.#ws = new WebSocket(url, {
+      headers: {
+        Origin: 'https://discord.com',
+        'User-Agent': UserAgent,
+      },
+    });
+    this.#handleWebSocket();
+  }
+
+  #clearHeartbeatTimer() {
+    if (!this.#heartbeatTimeout) return;
+    clearTimeout(this.#heartbeatTimeout);
+    this.#heartbeatTimeout = null;
+  }
+
+  #parseMessage(message) {
+    try {
+      const payload =
+        typeof message === 'string'
+          ? message
+          : Buffer.isBuffer(message)
+          ? message.toString('utf8')
+          : message?.data instanceof ArrayBuffer
+          ? Buffer.from(message.data).toString('utf8')
+          : Buffer.isBuffer(message?.data)
+          ? message.data.toString('utf8')
+          : message?.data ?? message;
+      const serialized = typeof payload === 'string' ? payload : String(payload);
+      return JSON.parse(serialized);
+    } catch (error) {
+      this.emit(Event.ERROR, error);
+      return null;
+    }
+  }
+
+  #handleWebSocket() {
+    this.#ws.on('error', error => {
+      /**
+       * WS Error
+       * @event DiscordAuthWebsocket#error
+       * @param {Error} error Error
+       */
+      this.emit(Event.ERROR, error);
+    });
+    this.#ws.on('open', () => {
+      /**
+       * Debug Event
+       * @event DiscordAuthWebsocket#debug
+       * @param {string} msg Debug msg
+       */
+      this.emit(Event.DEBUG, '[WS] Client Connected');
+    });
+    this.#ws.on('close', () => {
+      this.#clearHeartbeatTimer();
+      this.emit(Event.DEBUG, '[WS] Connection closed');
+    });
+    this.#ws.on('message', this.#handleMessage.bind(this));
+  }
+
+  #handleMessage(message) {
+    const payload = this.#parseMessage(message);
+    if (!payload) return;
+    switch (payload.op) {
+      case receiveEvent.HELLO: {
+        this.#ready(payload);
+        break;
+      }
+
+      case receiveEvent.NONCE_PROOF: {
+        this.#receiveNonceProof(payload);
+        break;
+      }
+
+      case receiveEvent.PENDING_REMOTE_INIT: {
+        this.#fingerprint = payload.fingerprint;
+        /**
+         * Ready Event
+         * @event DiscordAuthWebsocket#ready
+         * @param {DiscordAuthWebsocket} client WS
+         */
+        this.emit(Event.READY, this);
+        break;
+      }
+
+      case receiveEvent.HEARTBEAT_ACK: {
+        this.emit(Event.DEBUG, `Heartbeat acknowledged.`);
+        this.#heartbeatAck();
+        break;
+      }
+
+      case receiveEvent.PENDING_TICKET: {
+        this.#pendingLogin(payload);
+        break;
+      }
+
+      case receiveEvent.CANCEL: {
+        /**
+         * Cancel
+         * @event DiscordAuthWebsocket#cancel
+         * @param {DiscordAuthWebsocket} client WS
+         */
+        this.emit(Event.CANCEL, this);
+        this.destroy();
+        break;
+      }
+
+      case receiveEvent.PENDING_LOGIN: {
+        this.#ticket = payload.ticket;
+        this.#findRealToken();
+        break;
+      }
+    }
+  }
+
+  #send(op, data) {
+    if (!this.#ws || this.#ws.readyState !== WebSocket.OPEN) return;
+    let payload = { op: op };
+    if (data !== null) payload = { ...payload, ...data };
+    this.#ws.send(JSON.stringify(payload));
+  }
+
+  #heartbeatAck() {
+    this.#clearHeartbeatTimer();
+    this.#heartbeatTimeout = setTimeout(() => {
+      this.#send(sendEvent.HEARTBEAT);
+    }, this.#heartbeatInterval);
+    if (typeof this.#heartbeatTimeout.unref === 'function') {
+      this.#heartbeatTimeout.unref();
+    }
+  }
+
+  #ready(data) {
+    this.emit(Event.DEBUG, 'Attempting server handshake...');
+    this.#expire = new Date(Date.now() + data.timeout_ms);
+    this.#heartbeatInterval = data.heartbeat_interval;
+    this.#createKey();
+    this.#heartbeatAck();
+    this.#init();
+  }
+
+  #createKey() {
+    const key = crypto.generateKeyPairSync('rsa', {
+      modulusLength: 2048,
+      publicKeyEncoding: {
+        type: 'spki',
+        format: 'pem',
+      },
+      privateKeyEncoding: {
+        type: 'pkcs1',
+        format: 'pem',
+      },
+    });
+    this.#privateKey = typeof key.privateKey === 'string' ? key.privateKey : key.privateKey.toString('utf8');
+    this.#publicKey = typeof key.publicKey === 'string' ? key.publicKey : key.publicKey.toString('utf8');
+    this.#encodedPublicKey = this.#encodePublicKey();
+  }
+
+  #encodePublicKey() {
+    return this.#publicKey
+      .replace('-----BEGIN PUBLIC KEY-----\n', '')
+      .replace('\n-----END PUBLIC KEY-----\n', '')
+      .replace(/\n/g, '');
+  }
+
+  #init() {
+    this.#send(sendEvent.INIT, { encoded_public_key: this.#encodedPublicKey });
+  }
+
+  #receiveNonceProof(data) {
+    const nonce = data.encrypted_nonce;
+    const decrypted_nonce = this.#decryptPayload(nonce);
+    const proof = crypto.createHash('sha256').update(decrypted_nonce).digest('base64url');
+    this.#send(sendEvent.NONCE_PROOF, { proof: proof });
+  }
+
+  #decryptPayload(encrypted_payload) {
+    const payload = Buffer.from(encrypted_payload, 'base64');
+    const data = crypto.privateDecrypt(
+      {
+        key: this.#privateKey,
+        padding: crypto.constants.RSA_PKCS1_OAEP_PADDING,
+        oaepHash: 'sha256',
+      },
+      payload,
+    );
+    return data;
+  }
+
+  #pendingLogin(data) {
+    const user_data = this.#decryptPayload(data.encrypted_user_payload);
+    this.#userDecryptString = user_data.toString('utf8');
+
+    /**
+     * @typedef {Object} UserRaw
+     * @property {Snowflake} id
+     * @property {string} username
+     * @property {number} discriminator Legacy discriminator. Use `username` instead.
+     * @property {string} avatar
+     */
+
+    /**
+     * Emitted whenever a user is scan QR Code.
+     * @event DiscordAuthWebsocket#pending
+     * @param {UserRaw} user Discord User Raw
+     */
+    this.emit(Event.WAIT_SCAN, this.user);
+  }
+
+  #awaitLogin(client) {
+    return new Promise(r => {
+      this.once(Event.FINISH, token => {
+        r(client.login(token));
+      });
+    });
+  }
+
+  /**
+   * Connect WS
+   * @param {Client} [client] DiscordJS Client
+   * @returns {Promise<void>}
+   */
+  connect(client) {
+    this.#createWebSocket(wsURL);
+    if (client) {
+      return this.#awaitLogin(client);
+    } else {
+      return Promise.resolve();
+    }
+  }
+
+  /**
+   * Destroy client
+   * @returns {void}
+   */
+  destroy() {
+    if (!this.#ws) return;
+    this.#clearHeartbeatTimer();
+    this.#ws.close();
+    this.#ws = null;
+    this.emit(Event.DEBUG, 'WebSocket closed.');
+    /**
+     * Emitted whenever a connection is closed.
+     * @event DiscordAuthWebsocket#closed
+     */
+    this.emit(Event.CLOSED);
+  }
+
+  /**
+   * Generate QR code for user to scan (Terminal)
+   * @returns {void}
+   */
+  generateQR() {
+    if (!this.#fingerprint) return;
+    require('qrcode').toString(this.AuthURL, { type: 'utf8', errorCorrectionLevel: 'L' }, (err, url) => {
+      if (err) {
+        //
+      }
+      console.log(url);
+    });
+  }
+
+  async #findRealToken() {
+    try {
+      const response = await fetch(`https://discord.com/api/v9/users/@me/remote-auth/login`, {
+        method: 'POST',
+        headers: {
+          Accept: '*/*',
+          'Accept-Language': 'en-US',
+          'Content-Type': 'application/json',
+          'Sec-Fetch-Dest': 'empty',
+          'Sec-Fetch-Mode': 'cors',
+          'Sec-Fetch-Site': 'same-origin',
+          'X-Debug-Options': 'bugReporterEnabled',
+          'X-Super-Properties': superPropertiesBase64,
+          'X-Discord-Locale': 'en-US',
+          'User-Agent': UserAgent,
+          Referer: 'https://discord.com/channels/@me',
+          Connection: 'keep-alive',
+          Origin: 'https://discord.com',
+        },
+        body: JSON.stringify({
+          ticket: this.#ticket,
+        }),
+      });
+
+      if (!response.ok) {
+        throw new Error(`Remote auth exchange failed with status ${response.status}`);
+      }
+
+      const res = await response.json();
+      if (res.encrypted_token) {
+        this.token = this.#decryptPayload(res.encrypted_token).toString('utf8');
+      }
+      /**
+       * Emitted whenever a real token is found.
+       * @event DiscordAuthWebsocket#finish
+       * @param {string} token Discord Token
+       */
+      this.emit(Event.FINISH, this.token);
+    } catch (error) {
+      this.emit(Event.ERROR, error);
+    } finally {
+      this.destroy();
+    }
+  }
+
+  static decryptUser(payload) {
+    const values = payload.split(':');
+    const id = values[0];
+    const username = values[3];
+    const discriminator = values[1];
+    const avatar = values[2];
+    return {
+      id,
+      username,
+      discriminator,
+      avatar,
+    };
+  }
+}
+
+module.exports = DiscordAuthWebsocket;