@m7mdxzx1/discord-video-strem 0.0.1

package/src/client/Streamer.ts

@@ -0,0 +1,279 @@
+import { EventEmitter } from "node:events";
+import { VoiceConnection } from "./voice/VoiceConnection.js";
+import { StreamConnection } from "./voice/StreamConnection.js";
+import { GatewayOpCodes } from "./GatewayOpCodes.js";
+import type TypedEmitter from "typed-emitter";
+import type { Client, DMChannel, GroupDMChannel, VoiceBasedChannel } from 'discord.js-selfbot-v13';
+import type { MediaUdp } from "./voice/MediaUdp.js";
+import type { GatewayEvent } from "./GatewayEvents.js";
+import { generateStreamKey, parseStreamKey } from "../utils.js";
+
+type EmitterEvents = {
+    [K in GatewayEvent["t"]]: (data: Extract<GatewayEvent, { t: K }>["d"]) => void
+}
+
+export type StreamerOptions = {
+    /**
+     * Force the use of ChaCha20 encryption. Faster on CPUs without AES-NI
+     */
+    forceChacha20Encryption: boolean;
+    /**
+     * Enable RTCP Sender Report for synchronization
+     */
+    rtcpSenderReportEnabled: boolean
+}
+
+export class Streamer {
+    private _voiceConnection?: VoiceConnection;
+    private _client: Client;
+    private _opts: StreamerOptions;
+    private _gatewayEmitter = new EventEmitter() as TypedEmitter.default<EmitterEvents>
+
+    constructor(client: Client, opts?: Partial<StreamerOptions>) {
+        this._client = client;
+        this._opts = {
+            forceChacha20Encryption: false,
+            rtcpSenderReportEnabled: true,
+            ...opts
+        };
+
+        //listen for messages
+        this.client.on('raw', (packet: GatewayEvent) => {
+            // @ts-expect-error I don't know how to make this work with TypeScript, so whatever
+            this._gatewayEmitter.emit(packet.t, packet.d);
+        });
+    }
+
+    public get client(): Client {
+        return this._client;
+    }
+
+    public get opts(): StreamerOptions {
+        return this._opts;
+    }
+
+    public get voiceConnection(): VoiceConnection | undefined {
+        return this._voiceConnection;
+    }
+
+    public sendOpcode(code: number, data: unknown): void {
+        this.client.ws.broadcast({
+            op: code,
+            d: data,
+        });
+    }
+
+    public joinVoiceChannel(channel:  DMChannel | GroupDMChannel | VoiceBasedChannel): Promise<MediaUdp> {
+        let guildId: string | null = null;
+
+        if(channel.type === "GUILD_STAGE_VOICE" || channel.type === "GUILD_VOICE") {
+            guildId = channel.guildId
+        }
+
+        return this.joinVoice(guildId, channel.id);
+    }
+
+    /**
+     * Joins a voice channel and returns a MediaUdp object.
+     * @param guild_id the guild id of the voice channel. If null, it will join a DM voice channel.
+     * @param channel_id the channel id of the voice channel
+     * @returns the MediaUdp object
+     * @throws Error if the client is not logged in
+     */
+    public joinVoice(guild_id: string | null, channel_id: string): Promise<MediaUdp> {
+        return new Promise<MediaUdp>((resolve, reject) => {
+            if (!this.client.user) {
+                reject("Client not logged in");
+                return;
+            }
+            const user_id = this.client.user.id;
+            const voiceConn = new VoiceConnection(
+                this,
+                guild_id,
+                user_id,
+                channel_id,
+                (udp) => {
+                    resolve(udp)
+                }
+            );
+            this._voiceConnection = voiceConn;
+            this._gatewayEmitter.on("VOICE_STATE_UPDATE", (d) => {
+                if (user_id !== d.user_id) return;
+                voiceConn.setSession(d.session_id);
+            });
+            this._gatewayEmitter.on("VOICE_SERVER_UPDATE", (d) => {
+                if (guild_id !== d.guild_id) return;
+                
+                // channel_id is not set for guild voice calls
+                if(d.channel_id && (channel_id !== d.channel_id)) return;
+                
+                voiceConn.setTokens(d.endpoint, d.token);
+            })
+            this.signalVideo(false);
+        });
+    }
+
+    public createStream(): Promise<MediaUdp> {
+        return new Promise<MediaUdp>((resolve, reject) => {
+            if (!this.client.user) {
+                reject("Client not logged in");
+                return;
+            }
+            if (!this.voiceConnection) {
+                reject("cannot start stream without first joining voice channel");
+                return;
+            }
+
+            this.signalStream();
+            const {
+                guildId: clientGuildId,
+                channelId: clientChannelId,
+                session_id
+            } = this.voiceConnection;
+            const {
+                id: clientUserId
+            } = this.client.user;
+
+            if (!session_id)
+                throw new Error("Session doesn't exist yet");
+            const streamConn = new StreamConnection(
+                this,
+                clientGuildId,
+                clientUserId,
+                clientChannelId,
+                (udp) => {
+                    resolve(udp)
+                }
+            );
+            this.voiceConnection.streamConnection = streamConn;
+            this._gatewayEmitter.on("STREAM_CREATE", (d) => {
+                const { type, channelId, guildId, userId } = parseStreamKey(d.stream_key);
+
+                if (
+                    clientGuildId !== guildId ||
+                    clientChannelId !== channelId ||
+                    clientUserId !== userId
+                )
+                    return;
+
+                streamConn.serverId = d.rtc_server_id;
+                streamConn.streamKey = d.stream_key;
+                streamConn.setSession(session_id);
+            });
+            this._gatewayEmitter.on("STREAM_SERVER_UPDATE", (d) => {
+                const { type, channelId, guildId, userId } = parseStreamKey(d.stream_key);
+
+                if (
+                    clientGuildId !== guildId ||
+                    clientChannelId !== channelId ||
+                    clientUserId !== userId
+                )
+                    return;
+
+                streamConn.setTokens(d.endpoint, d.token);
+            })
+        });
+    }
+
+    public async setStreamPreview(image: Buffer): Promise<void> {
+        if (!this.client.token)
+            throw new Error("Please login :)");
+        if (!this.voiceConnection?.streamConnection?.guildId)
+            return;
+        const data = `data:image/jpeg;base64,${image.toString("base64")}`;
+        const { guildId } = this.voiceConnection.streamConnection;
+        const server = await this.client.guilds.fetch(guildId);
+        await server.members.me?.voice.postPreview(data);
+    }
+
+    public stopStream(): void {
+        const stream = this.voiceConnection?.streamConnection;
+
+        if (!stream) return;
+
+        stream.stop();
+
+        this.signalStopStream();
+
+        this.voiceConnection.streamConnection = undefined;
+        this._gatewayEmitter.removeAllListeners("STREAM_CREATE");
+        this._gatewayEmitter.removeAllListeners("STREAM_SERVER_UPDATE");
+    }
+
+    public leaveVoice(): void {
+        this.voiceConnection?.stop();
+
+        this.signalLeaveVoice();
+
+        this._voiceConnection = undefined;
+        this._gatewayEmitter.removeAllListeners("VOICE_STATE_UPDATE");
+        this._gatewayEmitter.removeAllListeners("VOICE_SERVER_UPDATE");
+    }
+
+    public signalVideo(video_enabled: boolean): void {
+        if (!this.voiceConnection)
+            return;
+        const {
+            guildId: guild_id,
+            channelId: channel_id,
+        } = this.voiceConnection;
+        this.sendOpcode(GatewayOpCodes.VOICE_STATE_UPDATE, {
+            guild_id: guild_id,
+            channel_id,
+            self_mute: false,
+            self_deaf: true,
+            self_video: video_enabled,
+        });
+    }
+
+    public signalStream(): void {
+        if (!this.voiceConnection)
+            return;
+        const {
+            type,
+            guildId: guild_id,
+            channelId: channel_id,
+            botId: user_id
+        } = this.voiceConnection;
+
+        const streamKey = generateStreamKey(type, guild_id, channel_id, user_id);
+
+        this.sendOpcode(GatewayOpCodes.STREAM_CREATE, {
+            type,
+            guild_id,
+            channel_id,
+            preferred_region: null,
+        });
+
+        this.sendOpcode(GatewayOpCodes.STREAM_SET_PAUSED, {
+            stream_key: streamKey,
+            paused: false,
+        });
+    }
+
+    public signalStopStream(): void {
+        if (!this.voiceConnection)
+            return;
+        const {
+            type,
+            guildId: guild_id,
+            channelId: channel_id,
+            botId: user_id
+        } = this.voiceConnection;
+
+        const streamKey = generateStreamKey(type, guild_id, channel_id, user_id);
+        this.sendOpcode(GatewayOpCodes.STREAM_DELETE, {
+            stream_key: streamKey
+        });
+    }
+
+    public signalLeaveVoice(): void {
+        this.sendOpcode(GatewayOpCodes.VOICE_STATE_UPDATE, {
+            guild_id: null,
+            channel_id: null,
+            self_mute: true,
+            self_deaf: false,
+            self_video: false,
+        });
+    }
+}

package/src/client/encryptor/TransportEncryptor.ts

@@ -0,0 +1,62 @@
+import sp from "sodium-plus";
+import { max_int32bit } from "../../utils.js";
+const { SodiumPlus } = sp;
+
+export interface TransportEncryptor {
+    encrypt(plaintext: Buffer, additionalData: Buffer): Promise<[Buffer, Buffer]>
+}
+
+export class AES256TransportEncryptor implements TransportEncryptor
+{
+    private _nonce = 0;
+    private _secretKey: Promise<CryptoKey>;
+    constructor(secretKey: Buffer)
+    {
+        this._secretKey = crypto.subtle.importKey("raw", 
+            secretKey,
+            {
+                name: "AES-GCM",
+                length: 32
+            },
+            false, ["encrypt"]
+        );
+    }
+    async encrypt(plaintext: Buffer, additionalData: Buffer): Promise<[Buffer, Buffer]> {
+        const nonceBuffer = Buffer.alloc(12);
+        nonceBuffer.writeUInt32BE(this._nonce);
+        this._nonce = (this._nonce + 1) % max_int32bit;
+        
+        const ciphertext = Buffer.from(await crypto.subtle.encrypt({
+            name: "AES-GCM",
+            iv: nonceBuffer,
+            additionalData,
+        }, await this._secretKey, plaintext));
+
+        return [ciphertext, nonceBuffer]
+    }
+}
+
+export class Chacha20TransportEncryptor implements TransportEncryptor
+{
+    private static sodium = SodiumPlus.auto();
+    private _nonce = 0;
+    private _secretKey: sp.CryptographyKey;
+    constructor(secretKey: Buffer)
+    {
+        this._secretKey = new sp.CryptographyKey(secretKey);
+    }
+    async encrypt(plaintext: Buffer, additionalData: Buffer): Promise<[Buffer, Buffer]> {
+        const nonceBuffer = Buffer.alloc(24);
+        nonceBuffer.writeUInt32BE(this._nonce);
+        this._nonce = (this._nonce + 1) % max_int32bit;
+
+        const ciphertext = await Chacha20TransportEncryptor.sodium
+            .then(s => s.crypto_aead_xchacha20poly1305_ietf_encrypt(
+                plaintext, nonceBuffer,
+                this._secretKey,
+                additionalData
+            ));
+
+        return [ciphertext, nonceBuffer];
+    }
+}

package/src/client/index.ts

@@ -0,0 +1,4 @@
+export * from './packet/index.js';
+export * from './voice/index.js';
+export * from "./GatewayOpCodes.js";
+export * from "./Streamer.js";

package/src/client/packet/AudioPacketizer.ts

@@ -0,0 +1,28 @@
+import type { MediaUdp } from "../voice/MediaUdp.js";
+import { BaseMediaPacketizer } from "./BaseMediaPacketizer.js";
+import { CodecPayloadType } from "../voice/BaseMediaConnection.js";
+
+export class AudioPacketizer extends BaseMediaPacketizer {
+    constructor(connection: MediaUdp, ssrc: number) {
+        super(connection, ssrc, CodecPayloadType.opus.payload_type);
+    }
+
+    public override async sendFrame(frame: Buffer, frametime: number): Promise<void> {
+        super.sendFrame(frame, frametime);
+        const packet = await this.createPacket(frame);
+        this.mediaUdp.sendPacket(packet);
+        this.onFrameSent(packet.length, frametime);
+    }
+
+    public async createPacket(chunk: Buffer): Promise<Buffer> {
+        const header = this.makeRtpHeader();
+
+        const [ciphertext, nonceBuffer] = await this.encryptData(chunk, header);
+        return Buffer.concat([header, ciphertext, nonceBuffer.subarray(0, 4)]);
+    }
+
+    public override async onFrameSent(bytesSent: number, frametime: number): Promise<void> {
+        await super.onFrameSent(1, bytesSent, frametime);
+        this.incrementTimestamp(frametime * (48000 / 1000));
+    }
+}

package/src/client/packet/BaseMediaPacketizer.ts

@@ -0,0 +1,307 @@
+import sp from "sodium-plus";
+import { Log } from "debug-level";
+import { webcrypto } from 'node:crypto';
+import { max_int16bit, max_int32bit, SupportedEncryptionModes } from "../../utils.js";
+import type { MediaUdp } from "../voice/MediaUdp.js";
+
+const { SodiumPlus, CryptographyKey } = sp;
+
+const ntpEpoch = new Date("Jan 01 1900 GMT").getTime();
+
+let sodium: Promise<sp.SodiumPlus> | undefined;
+
+export class BaseMediaPacketizer {
+    private _loggerRtcpSr = new Log("packetizer:rtcp-sr");
+
+    private _ssrc: number;
+    private _payloadType: number;
+    private _mtu: number;
+    private _sequence: number;
+    private _timestamp: number;
+
+    private _totalBytes: number;
+    private _totalPackets: number;
+    private _lastPacketTime: number;
+    private _lastRtcpTime: number;
+    private _currentMediaTimestamp: number;
+    private _srInterval: number;
+
+    private _mediaUdp: MediaUdp;
+    private _extensionEnabled: boolean;
+
+    constructor(connection: MediaUdp, ssrc: number, payloadType: number, extensionEnabled = false) {
+        this._mediaUdp = connection;
+        this._payloadType = payloadType;
+        this._ssrc = ssrc;
+        this._sequence = 0;
+        this._timestamp = 0;
+        this._totalBytes = 0;
+        this._totalPackets = 0;
+        this._lastPacketTime = 0;
+        this._lastRtcpTime = 0;
+        this._currentMediaTimestamp = 0;
+        this._mtu = 1200;
+        this._extensionEnabled = extensionEnabled;
+
+        this._srInterval = 1000;
+    }
+
+    public get ssrc(): number | undefined
+    {
+        return this._ssrc;
+    }
+
+    public set ssrc(value: number)
+    {
+        this._ssrc = value;
+        this._totalBytes = this._totalPackets = 0;
+    }
+
+    /**
+     * The interval between 2 consecutive RTCP Sender Report packets in ms
+     */
+    public get srInterval(): number
+    {
+        return this._srInterval;
+    }
+
+    public set srInterval(interval: number)
+    {
+        this._srInterval = interval;
+    }
+
+    public async sendFrame(frame: Buffer, frametime: number): Promise<void> {
+        // override this
+        this._lastPacketTime = Date.now();
+    }
+
+    public async onFrameSent(packetsSent: number, bytesSent: number, frametime: number): Promise<void> {
+        
+        if (this._mediaUdp.mediaConnection.streamer.opts.rtcpSenderReportEnabled)
+        {
+            this._totalPackets = this._totalPackets + packetsSent;
+            this._totalBytes = (this._totalBytes + bytesSent) % max_int32bit;
+
+            /**
+             * Not using modulo here, since the timestamp might not be an exact
+             * multiple of the interval
+             */
+            if (Math.floor(this._currentMediaTimestamp / this._srInterval) - Math.floor(this._lastRtcpTime / this._srInterval) > 0)
+            {
+                const senderReport = await this.makeRtcpSenderReport();
+                this._mediaUdp.sendPacket(senderReport);
+                this._lastRtcpTime = this._currentMediaTimestamp;
+                this._loggerRtcpSr.debug({
+                    stats: {
+                        ssrc: this._ssrc,
+                        timestamp: this._timestamp,
+                        totalPackets: this._totalPackets,
+                        totalBytes: this._totalBytes
+                    }
+                }, `Sent RTCP sender report for SSRC ${this._ssrc}`);
+            }
+        }
+        this._currentMediaTimestamp += frametime;
+    }
+
+    /**
+     * Partitions a buffer into chunks of length this.mtu
+     * @param data buffer to be partitioned
+     * @returns array of chunks
+     */
+    public partitionDataMTUSizedChunks(data: Buffer): Buffer[] {
+        let i = 0;
+        let len = data.length;
+    
+        const out = [];
+    
+        while (len > 0) {
+            const size = Math.min(len, this._mtu);
+            out.push(data.subarray(i, i + size));
+            len -= size;
+            i += size;
+        }
+    
+        return out;
+    }
+
+    public getNewSequence(): number {
+        this._sequence = (this._sequence + 1) % max_int16bit;
+        return this._sequence;
+    }
+
+    public incrementTimestamp(incrementBy: number): void {
+        this._timestamp = (this._timestamp + incrementBy) % max_int32bit;
+    }
+
+    public makeRtpHeader(isLastPacket = true): Buffer {
+        const packetHeader = Buffer.alloc(12);
+    
+        packetHeader[0] = 2 << 6 | ((this._extensionEnabled ? 1 : 0) << 4); // set version and flags
+        packetHeader[1] = this._payloadType; // set packet payload
+        if (isLastPacket)
+            packetHeader[1] |= 0b10000000; // mark M bit if last frame
+    
+        packetHeader.writeUIntBE(this.getNewSequence(), 2, 2);
+        packetHeader.writeUIntBE(this._timestamp, 4, 4);
+        packetHeader.writeUIntBE(this._ssrc, 8, 4);
+        return packetHeader;
+    }
+
+    public async makeRtcpSenderReport(): Promise<Buffer> {
+        const packetHeader = Buffer.allocUnsafe(8);
+
+        packetHeader[0] = 0x80; // RFC1889 v2, no padding, no reception report count
+        packetHeader[1] = 0xc8; // Type: Sender Report (200)
+
+        // Packet length (always 0x06 for some reason)
+        packetHeader[2] = 0x00;
+        packetHeader[3] = 0x06;
+        packetHeader.writeUInt32BE(this._ssrc, 4);
+
+        const senderReport = Buffer.allocUnsafe(20);
+
+        // Convert from floating point to 32.32 fixed point
+        // Convert each part separately to reduce precision loss
+        const ntpTimestamp = (this._lastPacketTime - ntpEpoch) / 1000;
+        const ntpTimestampMsw = Math.floor(ntpTimestamp);
+        const ntpTimestampLsw = Math.round((ntpTimestamp - ntpTimestampMsw) * max_int32bit);
+
+        senderReport.writeUInt32BE(ntpTimestampMsw, 0);
+        senderReport.writeUInt32BE(ntpTimestampLsw, 4);
+        senderReport.writeUInt32BE(this._timestamp, 8);
+        senderReport.writeUInt32BE(this._totalPackets % max_int32bit, 12);
+        senderReport.writeUInt32BE(this._totalBytes, 16);
+
+        const [ciphertext, nonceBuffer] = await this.encryptData(senderReport, packetHeader);
+        return Buffer.concat([
+            packetHeader, ciphertext,
+            nonceBuffer.subarray(0, 4)
+        ]);
+    }
+
+    /**
+     * Creates a one-byte extension header
+     * https://www.rfc-editor.org/rfc/rfc5285#section-4.2
+     * @returns extension header
+     */
+    public createExtensionHeader(extensions: { id: number, len: number, val: number}[]): Buffer {
+        /**
+         *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+            |      defined by profile       |           length              |
+            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+        */
+            const profile = Buffer.alloc(4);
+            profile[0] = 0xBE;
+            profile[1] = 0xDE;
+            profile.writeInt16BE(extensions.length, 2); // extension count
+
+            return profile
+    }
+
+    /**
+     * Creates a extension payload in one-byte format according to https://www.rfc-editor.org/rfc/rfc7941.html#section-4.1.1
+     * Discord seems to send this extension on every video packet. The extension ids for Discord can be found by connecting
+     * to their webrtc gateway using the webclient and the client will send an SDP offer containing it
+     * @returns extension payload
+     */
+    public createExtensionPayload(extensions: { id: number, len: number, val: number}[]): Buffer {
+        const extensionsData = [];
+        for(const ext of extensions){
+            /**
+             * EXTENSION DATA - each extension payload is 32 bits
+             */
+            const data = Buffer.alloc(4);
+
+            // https://webrtc.googlesource.com/src/+/refs/heads/main/docs/native-code/rtp-hdrext/playout-delay
+            if(ext.id === 5) {
+                /**
+                 *  0 1 2 3 4 5 6 7
+                    +-+-+-+-+-+-+-+-+
+                    |  ID   |  len  |
+                    +-+-+-+-+-+-+-+-+
+
+                where len = actual length - 1
+                */
+                data[0] = (ext.id & 0b00001111) << 4;
+                data[0] |= ((ext.len - 1) & 0b00001111);
+
+                /**  Specific to type playout-delay
+                 *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4
+                    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+                    |       MIN delay       |       MAX delay       |
+                    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+                */
+                data.writeUIntBE(ext.val, 1, 2); // not quite but its 0 anyway
+            }
+
+            extensionsData.push(data);
+        }
+
+        return Buffer.concat(extensionsData)
+    }
+
+    /**
+     * Encrypt packet payload. Encrpyed Payload is determined to be
+     * according to https://tools.ietf.org/html/rfc3711#section-3.1
+     * and https://datatracker.ietf.org/doc/html/rfc7714#section-8.2
+     * 
+     * Associated Data: The version V (2 bits), padding flag P (1 bit),
+                       extension flag X (1 bit), Contributing Source
+                       (CSRC) count CC (4 bits), marker M (1 bit),
+                       Payload Type PT (7 bits), sequence number
+                       (16 bits), timestamp (32 bits), SSRC (32 bits),
+                       optional CSRC identifiers (32 bits each), and
+                       optional RTP extension (variable length).
+
+      Plaintext:       The RTP payload (variable length), RTP padding
+                       (if used, variable length), and RTP pad count (if
+                       used, 1 octet).
+
+      Raw Data:        The optional variable-length SRTP Master Key
+                       Identifier (MKI) and SRTP authentication tag
+                       (whose use is NOT RECOMMENDED).  These fields are
+                       appended after encryption has been performed.
+
+        0                   1                   2                   3
+        0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    A  |V=2|P|X|  CC   |M|     PT      |       sequence number         |
+       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    A  |                           timestamp                           |
+       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    A  |           synchronization source (SSRC) identifier            |
+       +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+    A  |      contributing source (CSRC) identifiers (optional)        |
+    A  |                               ....                            |
+       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    A  |                   RTP extension header (OPTIONAL)             |
+       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    P  |                          payload  ...                         |
+    P  |                               +-------------------------------+
+    P  |                               | RTP padding   | RTP pad count |
+       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+                P = Plaintext (to be encrypted and authenticated)
+                A = Associated Data (to be authenticated only)
+     * @param plaintext 
+     * @param nonceBuffer
+     * @param additionalData 
+     * @returns ciphertext
+     */
+    public encryptData(plaintext: Buffer, additionalData: Buffer): Promise<[Buffer, Buffer]> {
+        const encryptor = this._mediaUdp.mediaConnection.transportEncryptor;
+        if (!encryptor)
+            throw new Error("Transport encryptor not defined. Did you forget to select protocol?");
+        return encryptor.encrypt(plaintext, additionalData);
+    }
+
+    public get mediaUdp(): MediaUdp {
+        return this._mediaUdp;
+    }
+
+    public get mtu(): number {
+        return this._mtu;
+    }
+}