djs-selfbot-v13 3.7.32 → 3.7.34

package/src/client/voice/networking/VoiceWebSocket.js

@@ -4,7 +4,8 @@ const EventEmitter = require('events');
 const { setTimeout, setInterval } = require('node:timers');
 const WebSocket = require('../../../WebSocket');
 const { Error } = require('../../../errors');
-const { Opcodes, VoiceOpcodes } = require('../../../util/Constants');
+const { Opcodes, VoiceOpcodes, VoiceStatus } = require('../../../util/Constants');
+const { DAVESession, getMaxProtocolVersion } = require('./DAVESession');
 
 /**
  * Represents a Voice Connection's WebSocket.
@@ -29,6 +30,7 @@ class VoiceWebSocket extends EventEmitter {
     this._sequenceNumber = -1;
 
     this.dead = false;
+    this._identified = false;
     this.connection.on('closing', this.shutdown.bind(this));
   }
 
@@ -57,6 +59,7 @@ class VoiceWebSocket extends EventEmitter {
       this.ws = null;
     }
     this.clearHeartbeat();
+    this._identified = false;
   }
 
   /**
@@ -67,7 +70,7 @@ class VoiceWebSocket extends EventEmitter {
     if (this.dead) return;
     if (this.ws) this.reset();
     if (this.attempts >= 5) {
-      this.emit('debug', new Error('VOICE_CONNECTION_ATTEMPTS_EXCEEDED', this.attempts));
+      this.emit('error', new Error('VOICE_CONNECTION_ATTEMPTS_EXCEEDED', this.attempts));
       return;
     }
 
@@ -87,13 +90,14 @@ class VoiceWebSocket extends EventEmitter {
 
   /**
    * Sends data to the WebSocket if it is open.
-   * @param {string} data The data to send to the WebSocket
-   * @returns {Promise<string>}
+   * @param {string|Buffer} data The data to send to the WebSocket
+   * @returns {Promise<string|Buffer>}
    */
   send(data) {
-    this.emit('debug', `[WS] >> ${data}`);
+    const preview = typeof data === 'string' ? data : `[bin] ${data.byteLength} bytes`;
+    this.emit('debug', `[WS] >> ${preview}`);
     return new Promise((resolve, reject) => {
-      if (!this.ws || this.ws.readyState !== WebSocket.OPEN) throw new Error('WS_NOT_OPEN', data);
+      if (!this.ws || this.ws.readyState !== WebSocket.OPEN) throw new Error('WS_NOT_OPEN', preview);
       this.ws.send(data, null, error => {
         if (error) reject(error);
         else resolve(data);
@@ -111,23 +115,48 @@ class VoiceWebSocket extends EventEmitter {
     return this.send(packet);
   }
 
+  /**
+   * Sends a binary message over the WebSocket.
+   * @param {number} opcode The opcode to use
+   * @param {Buffer} payload The payload to send
+   * @returns {Promise<Buffer>}
+   */
+  sendBinaryMessage(opcode, payload) {
+    const message = Buffer.concat([Buffer.from([opcode]), payload]);
+    return this.send(message);
+  }
+
   /**
    * Called whenever the WebSocket opens.
    */
   onOpen() {
     this.emit('debug', `[WS] opened at gateway ${this.connection.authentication.endpoint}`);
-    this.sendPacket({
-      op: Opcodes.DISPATCH,
-      d: {
-        server_id: this.connection.serverId || this.connection.channel.guild?.id || this.connection.channel.id,
-        user_id: this.client.user.id,
-        token: this.connection.authentication.token,
-        session_id: this.connection.authentication.sessionId,
-        streams: [{ type: 'screen', rid: '100', quality: 100 }],
-        video: true,
-      },
-    }).catch(() => {
-      this.emit('error', new Error('VOICE_JOIN_SOCKET_CLOSED'));
+  }
+
+  sendIdentify() {
+    if (this._identified) return Promise.resolve();
+    this._identified = true;
+
+    const isStream = this.connection.constructor.name === 'StreamConnection';
+    const sessionId = this.connection.authentication.sessionId;
+    const maxDave = getMaxProtocolVersion();
+    const data = {
+      server_id: this.connection.serverId || this.connection.channel.guild?.id || this.connection.channel.id,
+      user_id: this.client.user.id,
+      token: this.connection.authentication.token,
+      session_id: sessionId,
+    };
+    if (maxDave > 0) data.max_dave_protocol_version = maxDave;
+
+    if (isStream) {
+      data.channel_id = this.connection.channel.id;
+      data.streams = [{ type: 'screen', rid: '100', quality: 100 }];
+      data.video = true;
+    }
+
+    return this.sendPacket({
+      op: VoiceOpcodes.IDENTIFY,
+      d: data,
     });
   }
 
@@ -138,18 +167,105 @@ class VoiceWebSocket extends EventEmitter {
    */
   onMessage(event) {
     try {
-      return this.onPacket(WebSocket.unpack(event.data, 'json'));
+      const { data } = event;
+      if (data instanceof ArrayBuffer || Buffer.isBuffer(data)) {
+        const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
+        const seq = buffer.readUInt16BE(0);
+        const op = buffer.readUInt8(2);
+        const payload = buffer.subarray(3);
+        this._sequenceNumber = seq;
+        this.emit('debug', `[WS] << [bin] opcode ${op}, seq ${seq}, ${payload.byteLength} bytes`);
+        return this.onBinaryMessage({ op, seq, payload });
+      }
+      return this.onPacket(WebSocket.unpack(data, 'json'));
     } catch (error) {
       return this.onError(error);
     }
   }
 
+  usesSharedDaveSession() {
+    return (
+      this.connection.constructor.name === 'StreamConnection' &&
+      this.connection.voiceConnection?.dave === this.connection.dave
+    );
+  }
+
+  onBinaryMessage(message) {
+    const { dave } = this.connection;
+    if (!dave) return;
+    if (this.usesSharedDaveSession()) {
+      this.emit('debug', `[WS] << [bin] opcode ${message.op} ignored (shared MLS session)`);
+      return;
+    }
+
+    switch (message.op) {
+      case VoiceOpcodes.DAVE_MLS_EXTERNAL_SENDER:
+        dave.setExternalSender(message.payload);
+        break;
+      case VoiceOpcodes.DAVE_MLS_PROPOSALS: {
+        const payload = dave.processProposals(message.payload, this.connection.connectedClients);
+        if (payload) this.sendBinaryMessage(VoiceOpcodes.DAVE_MLS_COMMIT_WELCOME, payload);
+        break;
+      }
+      case VoiceOpcodes.DAVE_MLS_ANNOUNCE_COMMIT_TRANSITION: {
+        const { transitionId, success } = dave.processCommit(message.payload);
+        if (success) {
+          if (transitionId === 0) {
+            this.emit('transitioned', transitionId);
+          } else {
+            this.sendPacket({
+              op: VoiceOpcodes.DAVE_TRANSITION_READY,
+              d: { transition_id: transitionId },
+            });
+          }
+        }
+        break;
+      }
+      case VoiceOpcodes.DAVE_MLS_WELCOME: {
+        const { transitionId, success } = dave.processWelcome(message.payload);
+        if (success) {
+          if (transitionId === 0) {
+            this.emit('transitioned', transitionId);
+          } else {
+            this.sendPacket({
+              op: VoiceOpcodes.DAVE_TRANSITION_READY,
+              d: { transition_id: transitionId },
+            });
+          }
+        }
+        break;
+      }
+      default:
+        this.emit('unknownPacket', message);
+    }
+  }
+
   /**
    * Called whenever the connection to the WebSocket server is lost.
    * @param {CloseEvent} event The WebSocket close event
    */
   onClose(event) {
     this.emit('debug', `[WS] closed with code ${event.code} and reason: ${event.reason}`);
+    if (event.code === 4017) {
+      this.dead = true;
+      this.emit(
+        'error',
+        new Error('VOICE_DAVE_REQUIRED', 'Discord requires DAVE/E2EE protocol support. Ensure @snazzah/davey is installed.'),
+      );
+      return;
+    }
+    if (event.code === 4006) {
+      this.dead = true;
+      const guildId = this.connection.channel.guild?.id;
+      if (guildId) {
+        this.connection.channel.client.ws.broadcast({
+          op: Opcodes.VOICE_STATE_UPDATE,
+          d: { guild_id: guildId, channel_id: null, self_mute: false, self_deaf: false },
+        });
+      }
+      this.emit('error', new Error('VOICE_SESSION_EXPIRED'));
+      return;
+    }
     if (!this.dead) setTimeout(this.connect.bind(this), this.attempts * 1000).unref();
   }
 
@@ -162,6 +278,90 @@ class VoiceWebSocket extends EventEmitter {
     this.emit('error', error);
   }
 
+  setupDaveSession(protocolVersion) {
+    const isStream = this.connection.constructor.name === 'StreamConnection';
+    const parentDave = this.connection.voiceConnection?.dave;
+
+    if (isStream && parentDave?.session) {
+      this.connection.dave = parentDave;
+      this.connection.connectedClients.add(this.client.user.id);
+      for (const id of this.connection.voiceConnection.connectedClients) {
+        this.connection.connectedClients.add(id);
+      }
+      this.emit('debug', '[DAVE] Reusing parent voice connection MLS session');
+      return;
+    }
+
+    if (this.connection.dave) {
+      const isSharedDave = isStream && this.connection.dave === parentDave;
+      if (!isSharedDave) {
+        this.connection.dave.destroy();
+        this.connection.dave.removeAllListeners();
+      }
+    }
+
+    if (!protocolVersion || getMaxProtocolVersion() === 0) {
+      this.connection.dave = null;
+      return;
+    }
+
+    const session = new DAVESession(
+      protocolVersion,
+      this.client.user.id,
+      this.connection.channel.id,
+    );
+
+    session.on('debug', msg => this.emit('debug', `[DAVE] ${msg}`));
+    session.on('keyPackage', keyPackage => {
+      this.sendBinaryMessage(VoiceOpcodes.DAVE_MLS_KEY_PACKAGE, keyPackage).catch(e => this.emit('error', e));
+    });
+    session.on('invalidateTransition', transitionId => {
+      this.sendPacket({
+        op: VoiceOpcodes.DAVE_MLS_INVALID_COMMIT_WELCOME,
+        d: { transition_id: transitionId },
+      }).catch(e => this.emit('error', e));
+    });
+    session.on('error', err => this.emit('error', err));
+
+    this.connection.dave = session;
+    this.connection.connectedClients.add(this.client.user.id);
+    if (this.connection.voiceConnection?.connectedClients) {
+      for (const id of this.connection.voiceConnection.connectedClients) {
+        this.connection.connectedClients.add(id);
+      }
+    }
+    session.reinit();
+  }
+
+  handleDavePacket(packet) {
+    const { dave } = this.connection;
+    if (!dave) return;
+
+    switch (packet.op) {
+      case VoiceOpcodes.DAVE_PREPARE_TRANSITION: {
+        const sendReady = dave.prepareTransition(packet.d);
+        if (sendReady) {
+          this.sendPacket({
+            op: VoiceOpcodes.DAVE_TRANSITION_READY,
+            d: { transition_id: packet.d.transition_id },
+          });
+        }
+        if (packet.d.transition_id === 0) this.emit('transitioned', 0);
+        break;
+      }
+      case VoiceOpcodes.DAVE_EXECUTE_TRANSITION: {
+        const transitioned = dave.executeTransition(packet.d.transition_id);
+        if (transitioned) this.emit('transitioned', packet.d.transition_id);
+        break;
+      }
+      case VoiceOpcodes.DAVE_PREPARE_EPOCH:
+        dave.prepareEpoch(packet.d);
+        break;
+      default:
+        break;
+    }
+  }
+
   /**
    * Called whenever a valid packet is received from the WebSocket.
    * @param {Object} packet The received packet
@@ -169,9 +369,24 @@ class VoiceWebSocket extends EventEmitter {
   onPacket(packet) {
     this.emit('debug', `[WS] << ${JSON.stringify(packet)}`);
     if (packet.seq) this._sequenceNumber = packet.seq;
+
+    if (
+      [
+        VoiceOpcodes.DAVE_PREPARE_TRANSITION,
+        VoiceOpcodes.DAVE_EXECUTE_TRANSITION,
+        VoiceOpcodes.DAVE_PREPARE_EPOCH,
+      ].includes(packet.op)
+    ) {
+      if (!this.usesSharedDaveSession()) this.handleDavePacket(packet);
+      return;
+    }
+
     switch (packet.op) {
       case VoiceOpcodes.HELLO:
         this.setHeartbeat(packet.d.heartbeat_interval);
+        this.sendIdentify().catch(() => {
+          this.emit('error', new Error('VOICE_JOIN_SOCKET_CLOSED'));
+        });
         break;
       case VoiceOpcodes.READY:
         /**
@@ -180,11 +395,11 @@ class VoiceWebSocket extends EventEmitter {
          * @event VoiceWebSocket#ready
          */
         this.emit('ready', packet.d);
-        this.connection.setVideoStatus(false);
         break;
       /* eslint-disable no-case-declarations */
       case VoiceOpcodes.SESSION_DESCRIPTION:
         packet.d.secret_key = new Uint8Array(packet.d.secret_key);
+        this.setupDaveSession(packet.d.dave_protocol_version ?? 0);
         /**
          * Emitted once the Voice Websocket receives a description of this voice session.
          * @param {Object} packet The received packet
@@ -192,6 +407,9 @@ class VoiceWebSocket extends EventEmitter {
          */
         this.emit('sessionDescription', packet.d);
         break;
+      case VoiceOpcodes.CLIENTS_CONNECT:
+        for (const id of packet.d.user_ids) this.connection.connectedClients.add(id);
+        break;
       case VoiceOpcodes.CLIENT_CONNECT:
         this.connection.ssrcMap.set(+packet.d.audio_ssrc, {
           userId: packet.d.user_id,
@@ -200,6 +418,7 @@ class VoiceWebSocket extends EventEmitter {
         });
         break;
       case VoiceOpcodes.CLIENT_DISCONNECT:
+        this.connection.connectedClients.delete(packet.d.user_id);
         const streamInfo = this.connection.receiver && this.connection.receiver.packets.streams.get(packet.d.user_id);
         if (streamInfo) {
           this.connection.receiver.packets.streams.delete(packet.d.user_id);
@@ -258,10 +477,7 @@ class VoiceWebSocket extends EventEmitter {
    * Clears a heartbeat interval, if one exists.
    */
   clearHeartbeat() {
-    if (!this.heartbeatInterval) {
-      this.emit('warn', 'Tried to clear a heartbeat interval that does not exist');
-      return;
-    }
+    if (!this.heartbeatInterval) return;
     clearInterval(this.heartbeatInterval);
     this.heartbeatInterval = null;
   }

package/src/client/voice/player/MediaPlayer.js

@@ -214,7 +214,9 @@ class MediaPlayer extends EventEmitter {
       args.push(...FFMPEG_H265_ARGUMENTS(options));
     }
 
-    args.push('-force_key_frames', '00:02');
+    if (options?.fps) {
+      args.push('-g', String(options.fps), '-keyint_min', String(options.fps), '-sc_threshold', '0');
+    }
 
     if (options?.inputFFmpegArgs) {
       args.unshift(...options.inputFFmpegArgs);

package/src/client/voice/player/processing/AnnexBBitstreamReaderWriter.js

@@ -0,0 +1,137 @@
+'use strict';
+
+class AnnexBBitstreamReader {
+  constructor(buffer) {
+    this._buffer = buffer;
+    this._byteOffset = 0;
+    this._bitOffset = 0;
+  }
+
+  readBits(count) {
+    if (count === 0) return 0;
+    let result = 0;
+    while (count > 0) {
+      if (this._byteOffset >= this._buffer.length) throw new Error('Bad byte offset');
+      if (
+        this._bitOffset === 0 &&
+        this._byteOffset >= 2 &&
+        this._buffer[this._byteOffset - 2] === 0 &&
+        this._buffer[this._byteOffset - 1] === 0 &&
+        this._buffer[this._byteOffset] === 3
+      ) {
+        this._byteOffset++;
+      }
+      if (this._bitOffset === 0 && count >= 8) {
+        result = (result << 8) | this._buffer[this._byteOffset++];
+        count -= 8;
+      } else {
+        const numBitsToRead = Math.min(count, 8 - this._bitOffset);
+        const mask = (1 << numBitsToRead) - 1;
+        const newBits = (this._buffer[this._byteOffset] >> (8 - this._bitOffset - numBitsToRead)) & mask;
+        result = (result << numBitsToRead) | newBits;
+        count -= numBitsToRead;
+        this._bitOffset += numBitsToRead;
+        if (this._bitOffset === 8) {
+          this._bitOffset = 0;
+          this._byteOffset++;
+        }
+      }
+    }
+    return result;
+  }
+
+  readUnsigned(bits) {
+    return this.readBits(bits);
+  }
+
+  readSigned(bits) {
+    const unsigned = this.readUnsigned(bits);
+    if (unsigned & (1 << (bits - 1))) return unsigned - (1 << bits);
+    return unsigned;
+  }
+
+  readUnsignedExpGolomb() {
+    let leading0 = 0;
+    while (this.readBits(1) === 0) leading0++;
+    return (1 << leading0) + this.readBits(leading0) - 1;
+  }
+
+  readSignedExpGolomb() {
+    const unsigned = this.readUnsignedExpGolomb();
+    if (unsigned % 2 === 0) return unsigned / -2;
+    return (unsigned + 1) / 2;
+  }
+}
+
+class AnnexBBitstreamWriter {
+  constructor() {
+    this._arr = [];
+    this._pendingByte = 0;
+    this._bitOffset = 0;
+  }
+
+  toBuffer() {
+    return Buffer.from(this._arr);
+  }
+
+  flush() {
+    if (this._pendingByte <= 3 && this._arr.at(-1) === 0 && this._arr.at(-2) === 0) this._arr.push(3);
+    this._arr.push(this._pendingByte);
+    this._pendingByte = 0;
+    this._bitOffset = 0;
+  }
+
+  writeBits(bits, count) {
+    while (count > 0) {
+      if (this._bitOffset === 0) {
+        if (count >= 8) {
+          this._pendingByte = (bits >> (count - 8)) & 0xff;
+          count -= 8;
+          this.flush();
+        } else {
+          const mask = (1 << count) - 1;
+          this._pendingByte |= (bits & mask) << (8 - count);
+          this._bitOffset = count;
+          count = 0;
+        }
+      } else {
+        const numBitsToWrite = Math.min(8 - this._bitOffset, count);
+        const bitsToWrite = (bits >> (count - numBitsToWrite)) & ((1 << numBitsToWrite) - 1);
+        this._pendingByte |= bitsToWrite << (8 - this._bitOffset - numBitsToWrite);
+        count -= numBitsToWrite;
+        this._bitOffset += numBitsToWrite;
+        if (this._bitOffset === 8) {
+          this._bitOffset = 0;
+          this.flush();
+        }
+      }
+    }
+  }
+
+  writeUnsigned(num, count) {
+    if (num < 0) throw new Error('Expected a non-negative number');
+    this.writeBits(num, count);
+  }
+
+  writeSigned(num, count) {
+    if (count <= 0) return;
+    if (count > 32) throw new Error('writeSigned supports up to 32 bits');
+    const mask = count === 32 ? 0xffffffff >>> 0 : (((1 << count) >>> 0) - 1) >>> 0;
+    this.writeBits((num & mask) >>> 0, count);
+  }
+
+  writeUnsignedExpGolomb(num) {
+    if (num < 0) throw new Error('Expected a non-negative number');
+    num++;
+    const bitCount = 32 - Math.clz32(num >>> 0);
+    this.writeBits(0, bitCount - 1);
+    this.writeBits(num, bitCount);
+  }
+
+  writeSignedExpGolomb(num) {
+    if (num < 0) this.writeUnsignedExpGolomb(-2 * num);
+    else this.writeUnsignedExpGolomb(2 * num - 1);
+  }
+}
+
+module.exports = { AnnexBBitstreamReader, AnnexBBitstreamWriter };