djs-selfbot-v13 3.7.32 → 3.7.34

package/src/client/voice/dispatcher/AnnexBDispatcher.js

@@ -20,7 +20,8 @@ Please use the @dank074/discord-video-stream library for the best support.
 const { Buffer } = require('buffer');
 const VideoDispatcher = require('./VideoDispatcher');
 const Util = require('../../../util/Util');
-const { H264Helpers, H265Helpers } = require('../player/processing/AnnexBNalSplitter');
+const { H264Helpers, H265Helpers, H264NalUnitTypes, H265NalUnitTypes } = require('../player/processing/AnnexBNalSplitter');
+const { rewriteSPSVUI } = require('../player/processing/SPSVUIRewriter');
 
 class AnnexBDispatcher extends VideoDispatcher {
   constructor(player, highWaterMark = 12, streams, fps, nalFunctions, payloadType) {
@@ -28,8 +29,65 @@ class AnnexBDispatcher extends VideoDispatcher {
     this._nalFunctions = nalFunctions;
   }
 
+  _rewriteH264SPS(accessUnit) {
+    const parts = [];
+    let offset = 0;
+    while (offset < accessUnit.length) {
+      const naluSize = accessUnit.readUInt32BE(offset);
+      offset += 4;
+      let nalu = accessUnit.subarray(offset, offset + naluSize);
+      if (this._nalFunctions === H264Helpers && H264Helpers.getUnitType(nalu) === 7) {
+        try {
+          nalu = rewriteSPSVUI(nalu);
+        } catch {
+          // keep original SPS on rewrite failure
+        }
+      }
+      const header = Buffer.alloc(4);
+      header.writeUInt32BE(nalu.length);
+      parts.push(header, nalu);
+      offset += naluSize;
+    }
+    return Buffer.concat(parts);
+  }
+
+  _accessUnitIsKeyframe(accessUnit) {
+    let offset = 0;
+    while (offset < accessUnit.length) {
+      const naluSize = accessUnit.readUInt32BE(offset);
+      offset += 4;
+      const nalu = accessUnit.subarray(offset, offset + naluSize);
+      const unitType = this._nalFunctions.getUnitType(nalu);
+      if (this._nalFunctions === H264Helpers) {
+        if (unitType === H264NalUnitTypes.CodedSliceIdr) return true;
+      } else if (
+        unitType === H265NalUnitTypes.IDR_W_RADL ||
+        unitType === H265NalUnitTypes.IDR_N_LP ||
+        unitType === H265NalUnitTypes.CRA_NUT
+      ) {
+        return true;
+      }
+      offset += naluSize;
+    }
+    return false;
+  }
+
+  _sendVideoPacket(naluPayload, isLastPacket, isKeyframe) {
+    const includeContentType = isKeyframe && isLastPacket && this.player.isScreenSharing;
+    this._playChunk(
+      Buffer.concat([this.createPayloadExtension(includeContentType), naluPayload]),
+      isLastPacket,
+      { isKeyframe },
+    );
+  }
+
   _codecCallback(frame) {
-    let accessUnit = frame;
+    let accessUnit = this._nalFunctions === H264Helpers ? this._rewriteH264SPS(frame) : frame;
+    const isKeyframe = this._accessUnitIsKeyframe(accessUnit);
+    const dave = this.player.voiceConnection.dave;
+    if (dave?.session?.ready) {
+      accessUnit = dave.encryptVideo(accessUnit, this.player.voiceConnection.videoCodec);
+    }
     let offset = 0;
 
     // Extract NALUs from the access unit
@@ -39,24 +97,19 @@ class AnnexBDispatcher extends VideoDispatcher {
       const nalu = accessUnit.subarray(offset, offset + naluSize);
       const isLastNal = offset + naluSize >= accessUnit.length;
       if (nalu.length <= this.mtu) {
-        // Send as Single NAL Unit Packet.
-        this._playChunk(Buffer.concat([this.createPayloadExtension(), nalu]), isLastNal);
+        this._sendVideoPacket(nalu, isLastNal, isKeyframe);
       } else {
         const [naluHeader, naluData] = this._nalFunctions.splitHeader(nalu);
         const dataFragments = this.partitionMtu(naluData);
-        // Send as Fragmentation Unit A (FU-A):
         for (let fragmentIndex = 0; fragmentIndex < dataFragments.length; fragmentIndex++) {
           const data = dataFragments[fragmentIndex];
           const isFirstPacket = fragmentIndex === 0;
           const isFinalPacket = fragmentIndex === dataFragments.length - 1;
 
-          this._playChunk(
-            Buffer.concat([
-              this.createPayloadExtension(),
-              this.makeFragmentationUnitHeader(isFirstPacket, isFinalPacket, naluHeader),
-              data,
-            ]),
+          this._sendVideoPacket(
+            Buffer.concat([this.makeFragmentationUnitHeader(isFirstPacket, isFinalPacket, naluHeader), data]),
             isLastNal && isFinalPacket,
+            isKeyframe,
           );
         }
       }

package/src/client/voice/dispatcher/BaseDispatcher.js

@@ -5,6 +5,7 @@ const crypto = require('node:crypto');
 const { Writable } = require('node:stream');
 const { setTimeout } = require('node:timers');
 const secretbox = require('../util/Secretbox');
+const Speaking = require('../../../util/Speaking');
 
 const MAX_UINT_16 = 2 ** 16 - 1;
 const MAX_UINT_32 = 2 ** 32 - 1;
@@ -232,14 +233,16 @@ class BaseDispatcher extends Writable {
     callback();
   }
 
-  _playChunk(chunk, isLastPacket = false) {
+  _playChunk(chunk, isLastPacket = false, packetOpts = {}) {
     if (
       (this.player.dispatcher !== this && this.player.videoDispatcher !== this) ||
       !this.player.voiceConnection.authentication.secret_key
     ) {
       return;
     }
+    this._packetOpts = packetOpts;
     const packet = this._createPacket(chunk, isLastPacket);
+    this._packetOpts = null;
     if (packet) this._sendPacket(packet);
   }
 
@@ -375,7 +378,9 @@ class BaseDispatcher extends Writable {
     rtpHeader[0] = 0x80; // Version + Flags (1 byte)
     rtpHeader[1] = this.payloadType; // Payload Type (1 byte)
     if (this.extensionEnabled) {
-      rtpHeader = Buffer.concat([rtpHeader, this.createHeaderExtension()]);
+      const extensionWordCount =
+        typeof this.getExtensionWordCount === 'function' ? this.getExtensionWordCount(isLastPacket) : 1;
+      rtpHeader = Buffer.concat([rtpHeader, this.createHeaderExtension(extensionWordCount)]);
       rtpHeader[0] |= 1 << 4; // 0x90
     }
     if (this.getTypeDispatcher() === 'video' && isLastPacket) {
@@ -384,12 +389,11 @@ class BaseDispatcher extends Writable {
 
     rtpHeader.writeUIntBE(this.getNewSequence(), 2, 2);
     rtpHeader.writeUIntBE(this.timestamp, 4, 4);
-    rtpHeader.writeUIntBE(
-      this.player.voiceConnection.authentication.ssrc + Number(this.getTypeDispatcher() === 'video'),
-      8,
-      4,
-    );
-    return Buffer.concat([rtpHeader, ...this._encrypt(buffer, rtpHeader)]);
+    const { audioSsrc, videoSsrc } = this.player.voiceConnection.getStreamSsrcs();
+    rtpHeader.writeUIntBE(this.getTypeDispatcher() === 'video' ? videoSsrc : audioSsrc, 8, 4);
+    const dave = this.player.voiceConnection.dave;
+    const payload = this.getTypeDispatcher() === 'audio' && dave?.session?.ready ? dave.encrypt(buffer) : buffer;
+    return Buffer.concat([rtpHeader, ...this._encrypt(payload, rtpHeader)]);
   }
 
   _sendPacket(packet) {
@@ -399,7 +403,7 @@ class BaseDispatcher extends Writable {
      * @param {string} info The debug info
      */
     if (this.getTypeDispatcher() === 'audio') {
-      this._setSpeaking(this.player.isScreenSharing ? 1 << 1 : 1 << 0); // 1 << 0 = SPEAKING, 1 << 1 = SOUND SHARE
+      this._setSpeaking(this.player.isScreenSharing ? Speaking.FLAGS.SOUNDSHARE : Speaking.FLAGS.SPEAKING);
     } else if (this.getTypeDispatcher() === 'video') {
       this._setVideoStatus(true);
       this._setStreamStatus(false);

package/src/client/voice/dispatcher/VideoDispatcher.js

@@ -60,6 +60,39 @@ class VideoDispatcher extends BaseDispatcher {
     this.fps = value;
   }
 
+  shouldIncludeContentType(isLastPacket) {
+    return Boolean(
+      this.player.isScreenSharing && this._packetOpts?.isKeyframe && isLastPacket,
+    );
+  }
+
+  getExtensionWordCount(isLastPacket) {
+    return this.shouldIncludeContentType(isLastPacket) ? 2 : 1;
+  }
+
+  createHeaderExtension(extensionWordCount = 1) {
+    const profile = Buffer.alloc(4);
+    profile[0] = 0xbe;
+    profile[1] = 0xde;
+    profile.writeInt16BE(extensionWordCount, 2);
+    return profile;
+  }
+
+  createPayloadExtension(includeContentType = false) {
+    if (includeContentType) {
+      const data = Buffer.alloc(8);
+      data[0] = (5 << 4) | 1;
+      data.writeUIntBE(10, 1, 2);
+      data[3] = 6 << 4;
+      data[4] = 0x01;
+      return data;
+    }
+    const data = Buffer.alloc(4);
+    data[0] = (5 << 4) | 1;
+    data.writeUIntBE(10, 1, 2);
+    return data;
+  }
+
   _codecCallback() {
     throw new Error('The _codecCallback method must be implemented');
   }

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

@@ -0,0 +1,234 @@
+'use strict';
+
+const EventEmitter = require('events');
+const Davey = require('@snazzah/davey');
+
+const TRANSITION_EXPIRY = 10;
+const TRANSITION_EXPIRY_PENDING_DOWNGRADE = 24;
+const DEFAULT_DECRYPTION_FAILURE_TOLERANCE = 36;
+
+const SILENCE_FRAME = Buffer.from([0xf8, 0xff, 0xfe]);
+
+function getMaxProtocolVersion() {
+  return Davey.DAVE_PROTOCOL_VERSION ?? 0;
+}
+
+class DAVESession extends EventEmitter {
+  constructor(protocolVersion, userId, channelId, options = {}) {
+    super();
+    this.protocolVersion = protocolVersion;
+    this.userId = userId;
+    this.channelId = channelId;
+    this.failureTolerance = options.decryptionFailureTolerance ?? DEFAULT_DECRYPTION_FAILURE_TOLERANCE;
+    this.pendingTransitions = new Map();
+    this.downgraded = false;
+    this.consecutiveFailures = 0;
+    this.reinitializing = false;
+    this.lastTransitionId = undefined;
+    this.session = undefined;
+  }
+
+  get voicePrivacyCode() {
+    if (this.protocolVersion === 0 || !this.session?.voicePrivacyCode) return null;
+    return this.session.voicePrivacyCode;
+  }
+
+  async getVerificationCode(userId) {
+    if (!this.session) throw new Error('Session not available');
+    return this.session.getVerificationCode(userId);
+  }
+
+  reinit() {
+    if (this.protocolVersion > 0) {
+      if (this.session) {
+        this.session.reinit(this.protocolVersion, this.userId, this.channelId);
+        this.emit('debug', `Session reinitialized for protocol version ${this.protocolVersion}`);
+      } else {
+        this.session = new Davey.DAVESession(this.protocolVersion, this.userId, this.channelId);
+        this.emit('debug', `Session initialized for protocol version ${this.protocolVersion}`);
+      }
+      this.emit('keyPackage', this.session.getSerializedKeyPackage());
+    } else if (this.session) {
+      this.session.reset();
+      this.session.setPassthroughMode(true, TRANSITION_EXPIRY);
+      this.emit('debug', 'Session reset');
+    }
+  }
+
+  setExternalSender(externalSender) {
+    if (!this.session) throw new Error('No session available');
+    try {
+      this.session.setExternalSender(externalSender);
+      this.emit('debug', 'Set MLS external sender');
+    } catch (error) {
+      if (String(error).includes('AlreadyInGroup')) {
+        this.emit('debug', 'MLS external sender already set, skipping');
+        return;
+      }
+      throw error;
+    }
+  }
+
+  prepareTransition(data) {
+    this.emit('debug', `Preparing for transition (${data.transition_id}, v${data.protocol_version})`);
+    this.pendingTransitions.set(data.transition_id, data.protocol_version);
+
+    if (data.transition_id === 0) {
+      this.executeTransition(data.transition_id);
+    } else {
+      if (data.protocol_version === 0) this.session?.setPassthroughMode(true, TRANSITION_EXPIRY_PENDING_DOWNGRADE);
+      return true;
+    }
+
+    return false;
+  }
+
+  executeTransition(transitionId) {
+    this.emit('debug', `Executing transition (${transitionId})`);
+    if (!this.pendingTransitions.has(transitionId)) {
+      this.emit('debug', `Received execute transition, but we don't have a pending transition for ${transitionId}`);
+      return false;
+    }
+
+    const oldVersion = this.protocolVersion;
+    this.protocolVersion = this.pendingTransitions.get(transitionId);
+
+    if (oldVersion !== this.protocolVersion && this.protocolVersion === 0) {
+      this.downgraded = true;
+      this.emit('debug', 'Session downgraded');
+    } else if (transitionId > 0 && this.downgraded) {
+      this.downgraded = false;
+      this.session?.setPassthroughMode(true, TRANSITION_EXPIRY);
+      this.emit('debug', 'Session upgraded');
+    }
+
+    this.reinitializing = false;
+    this.lastTransitionId = transitionId;
+    this.emit('debug', `Transition executed (v${oldVersion} -> v${this.protocolVersion}, id: ${transitionId})`);
+    this.pendingTransitions.delete(transitionId);
+    return true;
+  }
+
+  prepareEpoch(data) {
+    this.emit('debug', `Preparing for epoch (${data.epoch})`);
+    if (data.epoch === 1) {
+      this.protocolVersion = data.protocol_version;
+      this.reinit();
+    }
+  }
+
+  recoverFromInvalidTransition(transitionId) {
+    if (this.reinitializing) return;
+    this.emit('debug', `Invalidating transition ${transitionId}`);
+    this.reinitializing = true;
+    this.consecutiveFailures = 0;
+    this.emit('invalidateTransition', transitionId);
+    this.reinit();
+  }
+
+  processProposals(payload, connectedClients) {
+    if (!this.session) throw new Error('No session available');
+    try {
+      const optype = payload.readUInt8(0);
+      const { commit, welcome } = this.session.processProposals(
+        optype,
+        payload.subarray(1),
+        Array.from(connectedClients),
+      );
+      this.emit('debug', 'MLS proposals processed');
+      if (!commit) return;
+      return welcome ? Buffer.concat([commit, welcome]) : commit;
+    } catch (error) {
+      this.emit('debug', `MLS proposals errored: ${error}`);
+      return null;
+    }
+  }
+
+  processCommit(payload) {
+    if (!this.session) throw new Error('No session available');
+    const transitionId = payload.readUInt16BE(0);
+    try {
+      this.session.processCommit(payload.subarray(2));
+      if (transitionId === 0) {
+        this.reinitializing = false;
+        this.lastTransitionId = transitionId;
+      } else {
+        this.pendingTransitions.set(transitionId, this.protocolVersion);
+      }
+      this.emit('debug', `MLS commit processed (transition id: ${transitionId})`);
+      return { transitionId, success: true };
+    } catch (error) {
+      this.emit('debug', `MLS commit errored from transition ${transitionId}: ${error}`);
+      this.recoverFromInvalidTransition(transitionId);
+      return { transitionId, success: false };
+    }
+  }
+
+  processWelcome(payload) {
+    if (!this.session) throw new Error('No session available');
+    const transitionId = payload.readUInt16BE(0);
+    try {
+      this.session.processWelcome(payload.subarray(2));
+      if (transitionId === 0) {
+        this.reinitializing = false;
+        this.lastTransitionId = transitionId;
+      } else {
+        this.pendingTransitions.set(transitionId, this.protocolVersion);
+      }
+      this.emit('debug', `MLS welcome processed (transition id: ${transitionId})`);
+      return { transitionId, success: true };
+    } catch (error) {
+      this.emit('debug', `MLS welcome errored from transition ${transitionId}: ${error}`);
+      this.recoverFromInvalidTransition(transitionId);
+      return { transitionId, success: false };
+    }
+  }
+
+  encrypt(packet) {
+    if (this.protocolVersion === 0 || !this.session?.ready || packet.equals(SILENCE_FRAME)) return packet;
+    return this.session.encryptOpus(packet);
+  }
+
+  encryptVideo(packet, codec = 'H264') {
+    if (this.protocolVersion === 0 || !this.session?.ready) return packet;
+    const codecMap = {
+      H264: Davey.Codec.H264,
+      VP8: Davey.Codec.VP8,
+      H265: Davey.Codec.H265,
+      AV1: Davey.Codec.AV1,
+    };
+    return this.session.encrypt(Davey.MediaType.VIDEO, codecMap[codec] ?? Davey.Codec.UNKNOWN, packet);
+  }
+
+  decrypt(packet, userId) {
+    const canDecrypt = this.session?.ready && (this.protocolVersion !== 0 || this.session?.canPassthrough(userId));
+    if (packet.equals(SILENCE_FRAME) || !canDecrypt || !this.session) return packet;
+    try {
+      const buffer = this.session.decrypt(userId, Davey.MediaType.AUDIO, packet);
+      this.consecutiveFailures = 0;
+      return buffer;
+    } catch (error) {
+      if (!this.reinitializing && this.pendingTransitions.size === 0) {
+        this.consecutiveFailures++;
+        this.emit('debug', `Failed to decrypt a packet (${this.consecutiveFailures} consecutive fails)`);
+        if (this.consecutiveFailures > this.failureTolerance) {
+          if (this.lastTransitionId) this.recoverFromInvalidTransition(this.lastTransitionId);
+          else throw error;
+        }
+      } else if (this.reinitializing) {
+        this.emit('debug', 'Failed to decrypt a packet (reinitializing session)');
+      } else if (this.pendingTransitions.size > 0) {
+        this.emit('debug', `Failed to decrypt a packet (${this.pendingTransitions.size} pending transition[s])`);
+      }
+    }
+    return null;
+  }
+
+  destroy() {
+    try {
+      this.session?.reset();
+    } catch {}
+  }
+}
+
+module.exports = { DAVESession, getMaxProtocolVersion };