@discordjs/voice 0.17.1-dev.1731672303-3669d5e11 → 0.18.0

package/README.md

@@ -51,9 +51,13 @@ try installing another.
 
 **Encryption Libraries (npm install):**
 
+> [!NOTE]
+> You only need to install one of these libraries if your system does not support `aes-256-gcm` (verify by running `require('node:crypto').getCiphers().includes('aes-256-gcm')`).
+
 - `sodium-native`: ^3.3.0
 - `sodium`: ^3.0.2
-- `tweetnacl`: ^1.0.3
+- `@stablelib/xchacha20poly1305`: ^2.0.0
+- `@noble/ciphers`: ^1.0.0
 - `libsodium-wrappers`: ^0.7.9
 
 **Opus Libraries (npm install):**

package/dist/index.js

@@ -162,6 +162,7 @@ __name(deleteAudioPlayer, "deleteAudioPlayer");
 
 // src/networking/Networking.ts
 var import_node_buffer3 = require("buffer");
+var import_node_crypto = __toESM(require("crypto"));
 var import_node_events3 = require("events");
 var import_v42 = require("discord-api-types/voice/v4");
 
@@ -169,66 +170,84 @@ var import_v42 = require("discord-api-types/voice/v4");
 var import_node_buffer = require("buffer");
 var libs = {
   "sodium-native": /* @__PURE__ */ __name((sodium) => ({
-    open: /* @__PURE__ */ __name((buffer, nonce2, secretKey) => {
-      if (buffer) {
-        const output = import_node_buffer.Buffer.allocUnsafe(buffer.length - sodium.crypto_box_MACBYTES);
-        if (sodium.crypto_secretbox_open_easy(output, buffer, nonce2, secretKey)) return output;
-      }
-      return null;
-    }, "open"),
-    close: /* @__PURE__ */ __name((opusPacket, nonce2, secretKey) => {
-      const output = import_node_buffer.Buffer.allocUnsafe(opusPacket.length + sodium.crypto_box_MACBYTES);
-      sodium.crypto_secretbox_easy(output, opusPacket, nonce2, secretKey);
-      return output;
-    }, "close"),
-    random: /* @__PURE__ */ __name((num, buffer = import_node_buffer.Buffer.allocUnsafe(num)) => {
-      sodium.randombytes_buf(buffer);
-      return buffer;
-    }, "random")
+    crypto_aead_xchacha20poly1305_ietf_decrypt: /* @__PURE__ */ __name((cipherText, additionalData, nonce2, key) => {
+      const message = import_node_buffer.Buffer.alloc(cipherText.length - sodium.crypto_aead_xchacha20poly1305_ietf_ABYTES);
+      sodium.crypto_aead_xchacha20poly1305_ietf_decrypt(message, null, cipherText, additionalData, nonce2, key);
+      return message;
+    }, "crypto_aead_xchacha20poly1305_ietf_decrypt"),
+    crypto_aead_xchacha20poly1305_ietf_encrypt: /* @__PURE__ */ __name((plaintext, additionalData, nonce2, key) => {
+      const cipherText = import_node_buffer.Buffer.alloc(plaintext.length + sodium.crypto_aead_xchacha20poly1305_ietf_ABYTES);
+      sodium.crypto_aead_xchacha20poly1305_ietf_encrypt(cipherText, plaintext, additionalData, null, nonce2, key);
+      return cipherText;
+    }, "crypto_aead_xchacha20poly1305_ietf_encrypt")
   }), "sodium-native"),
   sodium: /* @__PURE__ */ __name((sodium) => ({
-    open: sodium.api.crypto_secretbox_open_easy,
-    close: sodium.api.crypto_secretbox_easy,
-    random: /* @__PURE__ */ __name((num, buffer = import_node_buffer.Buffer.allocUnsafe(num)) => {
-      sodium.api.randombytes_buf(buffer);
-      return buffer;
-    }, "random")
+    crypto_aead_xchacha20poly1305_ietf_decrypt: /* @__PURE__ */ __name((cipherText, additionalData, nonce2, key) => {
+      return sodium.api.crypto_aead_xchacha20poly1305_ietf_decrypt(cipherText, additionalData, null, nonce2, key);
+    }, "crypto_aead_xchacha20poly1305_ietf_decrypt"),
+    crypto_aead_xchacha20poly1305_ietf_encrypt: /* @__PURE__ */ __name((plaintext, additionalData, nonce2, key) => {
+      return sodium.api.crypto_aead_xchacha20poly1305_ietf_encrypt(plaintext, additionalData, null, nonce2, key);
+    }, "crypto_aead_xchacha20poly1305_ietf_encrypt")
   }), "sodium"),
   "libsodium-wrappers": /* @__PURE__ */ __name((sodium) => ({
-    open: sodium.crypto_secretbox_open_easy,
-    close: sodium.crypto_secretbox_easy,
-    random: sodium.randombytes_buf
+    crypto_aead_xchacha20poly1305_ietf_decrypt: /* @__PURE__ */ __name((cipherText, additionalData, nonce2, key) => {
+      return sodium.crypto_aead_xchacha20poly1305_ietf_decrypt(null, cipherText, additionalData, nonce2, key);
+    }, "crypto_aead_xchacha20poly1305_ietf_decrypt"),
+    crypto_aead_xchacha20poly1305_ietf_encrypt: /* @__PURE__ */ __name((plaintext, additionalData, nonce2, key) => {
+      return sodium.crypto_aead_xchacha20poly1305_ietf_encrypt(plaintext, additionalData, null, nonce2, key);
+    }, "crypto_aead_xchacha20poly1305_ietf_encrypt")
   }), "libsodium-wrappers"),
-  tweetnacl: /* @__PURE__ */ __name((tweetnacl) => ({
-    open: tweetnacl.secretbox.open,
-    close: tweetnacl.secretbox,
-    random: tweetnacl.randomBytes
-  }), "tweetnacl")
+  "@stablelib/xchacha20poly1305": /* @__PURE__ */ __name((stablelib) => ({
+    crypto_aead_xchacha20poly1305_ietf_decrypt(plaintext, additionalData, nonce2, key) {
+      const crypto3 = new stablelib.XChaCha20Poly1305(key);
+      return crypto3.open(nonce2, plaintext, additionalData);
+    },
+    crypto_aead_xchacha20poly1305_ietf_encrypt(cipherText, additionalData, nonce2, key) {
+      const crypto3 = new stablelib.XChaCha20Poly1305(key);
+      return crypto3.seal(nonce2, cipherText, additionalData);
+    }
+  }), "@stablelib/xchacha20poly1305"),
+  "@noble/ciphers/chacha": /* @__PURE__ */ __name((noble) => ({
+    crypto_aead_xchacha20poly1305_ietf_decrypt(cipherText, additionalData, nonce2, key) {
+      const chacha = noble.xchacha20poly1305(key, nonce2, additionalData);
+      return chacha.decrypt(cipherText);
+    },
+    crypto_aead_xchacha20poly1305_ietf_encrypt(plaintext, additionalData, nonce2, key) {
+      const chacha = noble.xchacha20poly1305(key, nonce2, additionalData);
+      return chacha.encrypt(plaintext);
+    }
+  }), "@noble/ciphers/chacha")
 };
 var fallbackError = /* @__PURE__ */ __name(() => {
   throw new Error(
     `Cannot play audio as no valid encryption package is installed.
-- Install sodium, libsodium-wrappers, or tweetnacl.
+- Install one of:
+  - sodium
+  - libsodium-wrappers
+  - @stablelib/xchacha20poly1305
+  - @noble/ciphers.
 - Use the generateDependencyReport() function for more information.
 `
   );
 }, "fallbackError");
 var methods = {
-  open: fallbackError,
-  close: fallbackError,
-  random: fallbackError
+  crypto_aead_xchacha20poly1305_ietf_encrypt: fallbackError,
+  crypto_aead_xchacha20poly1305_ietf_decrypt: fallbackError
 };
-void (async () => {
+var secretboxLoadPromise = new Promise(async (resolve2) => {
   for (const libName of Object.keys(libs)) {
     try {
-      const lib = require(libName);
-      if (libName === "libsodium-wrappers" && lib.ready) await lib.ready;
+      const lib = await import(libName);
+      if (libName === "libsodium-wrappers" && lib.ready) {
+        await lib.ready;
+      }
       Object.assign(methods, libs[libName](lib));
       break;
     } catch {
     }
   }
-})();
+  resolve2();
+});
 
 // src/util/util.ts
 var noop = /* @__PURE__ */ __name(() => {
@@ -503,7 +522,10 @@ var VoiceWebSocket = class extends import_node_events2.EventEmitter {
 var CHANNELS = 2;
 var TIMESTAMP_INC = 48e3 / 100 * CHANNELS;
 var MAX_NONCE_SIZE = 2 ** 32 - 1;
-var SUPPORTED_ENCRYPTION_MODES = ["xsalsa20_poly1305_lite", "xsalsa20_poly1305_suffix", "xsalsa20_poly1305"];
+var SUPPORTED_ENCRYPTION_MODES = ["aead_xchacha20_poly1305_rtpsize"];
+if (import_node_crypto.default.getCiphers().includes("aes-256-gcm")) {
+  SUPPORTED_ENCRYPTION_MODES.unshift("aead_aes256_gcm_rtpsize");
+}
 var nonce = import_node_buffer3.Buffer.alloc(24);
 function stringifyState(state) {
   return JSON.stringify({
@@ -736,7 +758,7 @@ to ${stringifyState(newState)}`);
           sequence: randomNBit(16),
           timestamp: randomNBit(32),
           nonce: 0,
-          nonceBuffer: import_node_buffer3.Buffer.alloc(24),
+          nonceBuffer: encryptionMode === "aead_aes256_gcm_rtpsize" ? import_node_buffer3.Buffer.alloc(12) : import_node_buffer3.Buffer.alloc(24),
           speaking: false,
           packetsPlayed: 0
         }
@@ -840,15 +862,15 @@ to ${stringifyState(newState)}`);
    * @param connectionData - The current connection data of the instance
    */
   createAudioPacket(opusPacket, connectionData) {
-    const packetBuffer = import_node_buffer3.Buffer.alloc(12);
-    packetBuffer[0] = 128;
-    packetBuffer[1] = 120;
+    const rtpHeader = import_node_buffer3.Buffer.alloc(12);
+    rtpHeader[0] = 128;
+    rtpHeader[1] = 120;
     const { sequence, timestamp, ssrc } = connectionData;
-    packetBuffer.writeUIntBE(sequence, 2, 2);
-    packetBuffer.writeUIntBE(timestamp, 4, 4);
-    packetBuffer.writeUIntBE(ssrc, 8, 4);
-    packetBuffer.copy(nonce, 0, 0, 12);
-    return import_node_buffer3.Buffer.concat([packetBuffer, ...this.encryptOpusPacket(opusPacket, connectionData)]);
+    rtpHeader.writeUIntBE(sequence, 2, 2);
+    rtpHeader.writeUIntBE(timestamp, 4, 4);
+    rtpHeader.writeUIntBE(ssrc, 8, 4);
+    rtpHeader.copy(nonce, 0, 0, 12);
+    return import_node_buffer3.Buffer.concat([rtpHeader, ...this.encryptOpusPacket(opusPacket, connectionData, rtpHeader)]);
   }
   /**
    * Encrypts an Opus packet using the format agreed upon by the instance and Discord.
@@ -856,26 +878,39 @@ to ${stringifyState(newState)}`);
    * @param opusPacket - The Opus packet to encrypt
    * @param connectionData - The current connection data of the instance
    */
-  encryptOpusPacket(opusPacket, connectionData) {
+  encryptOpusPacket(opusPacket, connectionData, additionalData) {
     const { secretKey, encryptionMode } = connectionData;
-    if (encryptionMode === "xsalsa20_poly1305_lite") {
-      connectionData.nonce++;
-      if (connectionData.nonce > MAX_NONCE_SIZE) connectionData.nonce = 0;
-      connectionData.nonceBuffer.writeUInt32BE(connectionData.nonce, 0);
-      return [
-        methods.close(opusPacket, connectionData.nonceBuffer, secretKey),
-        connectionData.nonceBuffer.slice(0, 4)
-      ];
-    } else if (encryptionMode === "xsalsa20_poly1305_suffix") {
-      const random = methods.random(24, connectionData.nonceBuffer);
-      return [methods.close(opusPacket, random, secretKey), random];
-    }
-    return [methods.close(opusPacket, nonce, secretKey)];
+    connectionData.nonce++;
+    if (connectionData.nonce > MAX_NONCE_SIZE) connectionData.nonce = 0;
+    connectionData.nonceBuffer.writeUInt32BE(connectionData.nonce, 0);
+    const noncePadding = connectionData.nonceBuffer.subarray(0, 4);
+    let encrypted;
+    switch (encryptionMode) {
+      case "aead_aes256_gcm_rtpsize": {
+        const cipher = import_node_crypto.default.createCipheriv("aes-256-gcm", secretKey, connectionData.nonceBuffer);
+        cipher.setAAD(additionalData);
+        encrypted = import_node_buffer3.Buffer.concat([cipher.update(opusPacket), cipher.final(), cipher.getAuthTag()]);
+        return [encrypted, noncePadding];
+      }
+      case "aead_xchacha20_poly1305_rtpsize": {
+        encrypted = methods.crypto_aead_xchacha20poly1305_ietf_encrypt(
+          opusPacket,
+          additionalData,
+          connectionData.nonceBuffer,
+          secretKey
+        );
+        return [encrypted, noncePadding];
+      }
+      default: {
+        throw new RangeError(`Unsupported encryption method: ${encryptionMode}`);
+      }
+    }
   }
 };
 
 // src/receive/VoiceReceiver.ts
 var import_node_buffer5 = require("buffer");
+var import_node_crypto2 = __toESM(require("crypto"));
 var import_v43 = require("discord-api-types/voice/v4");
 
 // src/receive/AudioReceiveStream.ts
@@ -1466,6 +1501,9 @@ var SpeakingMap = class _SpeakingMap extends import_node_events6.EventEmitter {
 };
 
 // src/receive/VoiceReceiver.ts
+var HEADER_EXTENSION_BYTE = import_node_buffer5.Buffer.from([190, 222]);
+var UNPADDED_NONCE_LENGTH = 4;
+var AUTH_TAG_LENGTH = 16;
 var VoiceReceiver = class {
   static {
     __name(this, "VoiceReceiver");
@@ -1521,19 +1559,37 @@ var VoiceReceiver = class {
     }
   }
   decrypt(buffer, mode, nonce2, secretKey) {
-    let end;
-    if (mode === "xsalsa20_poly1305_lite") {
-      buffer.copy(nonce2, 0, buffer.length - 4);
-      end = buffer.length - 4;
-    } else if (mode === "xsalsa20_poly1305_suffix") {
-      buffer.copy(nonce2, 0, buffer.length - 24);
-      end = buffer.length - 24;
-    } else {
-      buffer.copy(nonce2, 0, 0, 12);
+    buffer.copy(nonce2, 0, buffer.length - UNPADDED_NONCE_LENGTH);
+    let headerSize = 12;
+    const first = buffer.readUint8();
+    if (first >> 4 & 1) headerSize += 4;
+    const header = buffer.subarray(0, headerSize);
+    const encrypted = buffer.subarray(headerSize, buffer.length - AUTH_TAG_LENGTH - UNPADDED_NONCE_LENGTH);
+    const authTag = buffer.subarray(
+      buffer.length - AUTH_TAG_LENGTH - UNPADDED_NONCE_LENGTH,
+      buffer.length - UNPADDED_NONCE_LENGTH
+    );
+    switch (mode) {
+      case "aead_aes256_gcm_rtpsize": {
+        const decipheriv = import_node_crypto2.default.createDecipheriv("aes-256-gcm", secretKey, nonce2);
+        decipheriv.setAAD(header);
+        decipheriv.setAuthTag(authTag);
+        return import_node_buffer5.Buffer.concat([decipheriv.update(encrypted), decipheriv.final()]);
+      }
+      case "aead_xchacha20_poly1305_rtpsize": {
+        return import_node_buffer5.Buffer.from(
+          methods.crypto_aead_xchacha20poly1305_ietf_decrypt(
+            import_node_buffer5.Buffer.concat([encrypted, authTag]),
+            header,
+            nonce2,
+            secretKey
+          )
+        );
+      }
+      default: {
+        throw new RangeError(`Unsupported decryption method: ${mode}`);
+      }
     }
-    const decrypted = methods.open(buffer.slice(12, end), nonce2, secretKey);
-    if (!decrypted) return;
-    return import_node_buffer5.Buffer.from(decrypted);
   }
   /**
    * Parses an audio packet, decrypting it to yield an Opus packet.
@@ -1547,9 +1603,9 @@ var VoiceReceiver = class {
   parsePacket(buffer, mode, nonce2, secretKey) {
     let packet = this.decrypt(buffer, mode, nonce2, secretKey);
     if (!packet) return;
-    if (packet[0] === 190 && packet[1] === 222) {
-      const headerExtensionLength = packet.readUInt16BE(2);
-      packet = packet.subarray(4 + 4 * headerExtensionLength);
+    if (buffer.subarray(12, 14).compare(HEADER_EXTENSION_BYTE) === 0) {
+      const headerExtensionLength = buffer.subarray(14).readUInt16BE();
+      packet = packet.subarray(4 * headerExtensionLength);
     }
     return packet;
   }
@@ -2432,7 +2488,7 @@ __name(findPackageJSON, "findPackageJSON");
 function version(name) {
   try {
     if (name === "@discordjs/voice") {
-      return "0.17.1-dev.1731672303-3669d5e11";
+      return "0.18.0";
     }
     const pkg = findPackageJSON((0, import_node_path.dirname)(require.resolve(name)), name, 3);
     return pkg?.version ?? "not found";
@@ -2456,7 +2512,8 @@ function generateDependencyReport() {
   addVersion("sodium-native");
   addVersion("sodium");
   addVersion("libsodium-wrappers");
-  addVersion("tweetnacl");
+  addVersion("@stablelib/xchacha20poly1305");
+  addVersion("@noble/ciphers");
   report.push("");
   report.push("FFmpeg");
   try {
@@ -2575,7 +2632,7 @@ async function demuxProbe(stream, probeSize = 1024, validator = validateDiscordO
 __name(demuxProbe, "demuxProbe");
 
 // src/index.ts
-var version2 = "0.17.1-dev.1731672303-3669d5e11";
+var version2 = "0.18.0";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AudioPlayer,