@lakutata/webrtc 0.0.0-stage → 3.1.1

package/dist/cjs/lib/rtp/rtp/rtp.js

@@ -0,0 +1,271 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RtpPacket = exports.RtpHeader = exports.ExtensionProfiles = void 0;
+const index_js_1 = require("../../common/index.js");
+exports.ExtensionProfiles = {
+    OneByte: 0xbede, // 48862
+    TwoByte: 0x1000 // 4096
+};
+const seqNumOffset = 2;
+const timestampOffset = 4;
+const ssrcOffset = 8;
+const csrcOffset = 12;
+const csrcSize = 4;
+/*
+ *  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
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * |V=2|P|X|  CC   |M|     PT      |       sequence number         |
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * |                           timestamp                           |
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * |           synchronization source (SSRC) identifier            |
+ * +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+ * |            contributing source (CSRC) identifiers             |
+ * |                             ....                              |
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ */
+class RtpHeader {
+    constructor(props = {}) {
+        this.version = 2;
+        this.padding = false;
+        this.paddingSize = 0;
+        this.extension = false;
+        this.marker = false;
+        this.payloadOffset = 0;
+        this.payloadType = 0;
+        /**16bit, 初期値はランダムである必要があります*/
+        this.sequenceNumber = 0;
+        /**32bit microsec (milli/1000), 初期値はランダムである必要があります*/
+        this.timestamp = 0;
+        this.ssrc = 0;
+        this.csrcLength = 0;
+        this.csrc = [];
+        this.extensionProfile = exports.ExtensionProfiles.OneByte;
+        this.extensions = [];
+        Object.assign(this, props);
+    }
+    static deSerialize(rawPacket) {
+        const h = new RtpHeader();
+        let currOffset = 0;
+        const v_p_x_cc = rawPacket[currOffset++];
+        h.version = (0, index_js_1.getBit)(v_p_x_cc, 0, 2);
+        h.padding = (0, index_js_1.getBit)(v_p_x_cc, 2) > 0;
+        h.extension = (0, index_js_1.getBit)(v_p_x_cc, 3) > 0;
+        h.csrcLength = (0, index_js_1.getBit)(v_p_x_cc, 4, 4);
+        h.csrc = [...Array(h.csrcLength)].map(() => {
+            const csrc = rawPacket.readUInt32BE(currOffset);
+            currOffset += 4;
+            return csrc;
+        });
+        currOffset += csrcOffset - 1;
+        const m_pt = rawPacket[1];
+        h.marker = (0, index_js_1.getBit)(m_pt, 0) > 0;
+        h.payloadType = (0, index_js_1.getBit)(m_pt, 1, 7);
+        h.sequenceNumber = rawPacket.readUInt16BE(seqNumOffset);
+        h.timestamp = rawPacket.readUInt32BE(timestampOffset);
+        h.ssrc = rawPacket.readUInt32BE(ssrcOffset);
+        for (let i = 0; i < h.csrc.length; i++) {
+            const offset = csrcOffset + i * csrcSize;
+            h.csrc[i] = rawPacket.subarray(offset).readUInt32BE();
+        }
+        if (h.extension) {
+            h.extensionProfile = rawPacket
+                .subarray(currOffset)
+                .readUInt16BE();
+            currOffset += 2;
+            const extensionLength = rawPacket.subarray(currOffset).readUInt16BE() * 4;
+            h.extensionLength = extensionLength;
+            currOffset += 2;
+            switch (h.extensionProfile) {
+                // RFC 8285 RTP One Byte Header Extension
+                case exports.ExtensionProfiles.OneByte:
+                    {
+                        const end = currOffset + extensionLength;
+                        while (currOffset < end) {
+                            if (rawPacket[currOffset] === 0x00) {
+                                currOffset++;
+                                continue;
+                            }
+                            const extId = rawPacket[currOffset] >> 4;
+                            const len = (rawPacket[currOffset] & (rawPacket[currOffset] ^ 0xf0)) + 1; // and not &^
+                            currOffset++;
+                            if (extId === 0xf) {
+                                break;
+                            }
+                            const extension = {
+                                id: extId,
+                                payload: rawPacket.subarray(currOffset, currOffset + len)
+                            };
+                            h.extensions = [...h.extensions, extension];
+                            currOffset += len;
+                        }
+                    }
+                    break;
+                // RFC 8285 RTP Two Byte Header Extension
+                case exports.ExtensionProfiles.TwoByte:
+                    {
+                        const end = currOffset + extensionLength;
+                        while (currOffset < end) {
+                            if (rawPacket[currOffset] === 0x00) {
+                                currOffset++;
+                                continue;
+                            }
+                            const extId = rawPacket[currOffset];
+                            currOffset++;
+                            const len = rawPacket[currOffset];
+                            currOffset++;
+                            const extension = {
+                                id: extId,
+                                payload: rawPacket.subarray(currOffset, currOffset + len)
+                            };
+                            h.extensions = [...h.extensions, extension];
+                            currOffset += len;
+                        }
+                    }
+                    break;
+                default:
+                    {
+                        const extension = {
+                            id: 0,
+                            payload: rawPacket.subarray(currOffset, currOffset + extensionLength)
+                        };
+                        h.extensions = [...h.extensions, extension];
+                        currOffset += h.extensions[0].payload.length;
+                    }
+                    break;
+            }
+        }
+        h.payloadOffset = currOffset;
+        if (h.padding) {
+            h.paddingSize = rawPacket[rawPacket.length - 1];
+        }
+        return h;
+    }
+    get serializeSize() {
+        const { csrc, extensionProfile, extensions } = this;
+        let size = 12 + csrc.length * csrcSize;
+        if (extensions.length > 0 || this.extension === true) {
+            let extSize = 4;
+            switch (extensionProfile) {
+                case exports.ExtensionProfiles.OneByte:
+                    for (const extension of extensions) {
+                        extSize += 1 + extension.payload.length;
+                    }
+                    break;
+                case exports.ExtensionProfiles.TwoByte:
+                    for (const extension of extensions) {
+                        extSize += 2 + extension.payload.length;
+                    }
+                    break;
+                default:
+                    extSize += extensions[0].payload.length;
+            }
+            size += Math.floor((extSize + 3) / 4) * 4;
+        }
+        return size;
+    }
+    serialize(size) {
+        const buf = Buffer.alloc(size);
+        let offset = 0;
+        const v_p_x_cc = new index_js_1.BitWriter(8);
+        v_p_x_cc.set(2, 0, this.version);
+        if (this.padding)
+            v_p_x_cc.set(1, 2, 1);
+        if (this.extensions.length > 0)
+            this.extension = true;
+        if (this.extension)
+            v_p_x_cc.set(1, 3, 1);
+        v_p_x_cc.set(4, 4, this.csrc.length);
+        buf.writeUInt8(v_p_x_cc.value, offset++);
+        const m_pt = new index_js_1.BitWriter(8);
+        if (this.marker)
+            m_pt.set(1, 0, 1);
+        m_pt.set(7, 1, this.payloadType);
+        buf.writeUInt8(m_pt.value, offset++);
+        buf.writeUInt16BE(this.sequenceNumber, seqNumOffset);
+        offset += 2;
+        buf.writeUInt32BE(this.timestamp, timestampOffset);
+        offset += 4;
+        buf.writeUInt32BE(this.ssrc, ssrcOffset);
+        offset += 4;
+        for (const csrc of this.csrc) {
+            buf.writeUInt32BE(csrc, offset);
+            offset += 4;
+        }
+        if (this.extension) {
+            const extHeaderPos = offset;
+            buf.writeUInt16BE(this.extensionProfile, offset);
+            offset += 4;
+            const startExtensionsPos = offset;
+            switch (this.extensionProfile) {
+                case exports.ExtensionProfiles.OneByte:
+                    for (const extension of this.extensions) {
+                        buf.writeUInt8((extension.id << 4) | (extension.payload.length - 1), offset++);
+                        extension.payload.copy(buf, offset);
+                        offset += extension.payload.length;
+                    }
+                    break;
+                case exports.ExtensionProfiles.TwoByte: // 1バイトで収まらなくなった歴史的経緯
+                    for (const extension of this.extensions) {
+                        buf.writeUInt8(extension.id, offset++);
+                        buf.writeUInt8(extension.payload.length, offset++);
+                        extension.payload.copy(buf, offset);
+                        offset += extension.payload.length;
+                    }
+                    break;
+                default: {
+                    const extLen = this.extensions[0].payload.length;
+                    if (extLen % 4 != 0) {
+                        throw new Error();
+                    }
+                    this.extensions[0].payload.copy(buf, offset);
+                    offset += extLen;
+                }
+            }
+            const extSize = offset - startExtensionsPos;
+            const roundedExtSize = Math.trunc((extSize + 3) / 4) * 4;
+            buf.writeUInt16BE(Math.trunc(roundedExtSize / 4), extHeaderPos + 2);
+            // padding 4 bytes boundaries
+            for (let i = 0; i < roundedExtSize - extSize; i++) {
+                buf.writeUInt8(0, offset);
+                offset++;
+            }
+        }
+        this.payloadOffset = offset;
+        return buf;
+    }
+}
+exports.RtpHeader = RtpHeader;
+class RtpPacket {
+    constructor(header, payload) {
+        this.header = header;
+        this.payload = payload;
+    }
+    get serializeSize() {
+        return this.header.serializeSize + this.payload.length;
+    }
+    clone() {
+        return new RtpPacket(new RtpHeader({ ...this.header }), this.payload);
+    }
+    serialize() {
+        let buf = this.header.serialize(this.header.serializeSize + this.payload.length);
+        const { payloadOffset } = this.header;
+        this.payload.copy(buf, payloadOffset);
+        if (this.header.padding) {
+            const padding = Buffer.alloc(this.header.paddingSize);
+            padding.writeUInt8(this.header.paddingSize, this.header.paddingSize - 1);
+            buf = Buffer.concat([buf, padding]);
+        }
+        return buf;
+    }
+    static deSerialize(buf) {
+        const header = RtpHeader.deSerialize(buf);
+        const p = new RtpPacket(header, buf.subarray(header.payloadOffset, buf.length - header.paddingSize));
+        return p;
+    }
+    clear() {
+        this.payload = null;
+    }
+}
+exports.RtpPacket = RtpPacket;

package/dist/cjs/lib/rtp/rtp/rtx.d.ts

@@ -0,0 +1,3 @@
+import { RtpPacket } from './rtp.js';
+export declare function unwrapRtx(rtx: RtpPacket, payloadType: number, ssrc: number): RtpPacket;
+export declare function wrapRtx(packet: RtpPacket, payloadType: number, sequenceNumber: number, ssrc: number): RtpPacket;

package/dist/cjs/lib/rtp/rtp/rtx.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unwrapRtx = unwrapRtx;
+exports.wrapRtx = wrapRtx;
+const rtp_js_1 = require("./rtp.js");
+function unwrapRtx(rtx, payloadType, ssrc) {
+    const packet = new rtp_js_1.RtpPacket(new rtp_js_1.RtpHeader({
+        payloadType,
+        marker: rtx.header.marker,
+        sequenceNumber: rtx.payload.readUInt16BE(0),
+        timestamp: rtx.header.timestamp,
+        ssrc
+    }), rtx.payload.subarray(2));
+    return packet;
+}
+function wrapRtx(packet, payloadType, sequenceNumber, ssrc) {
+    const originalSequence = Buffer.allocUnsafe(2);
+    originalSequence.writeUInt16BE(packet.header.sequenceNumber, 0);
+    const rtx = new rtp_js_1.RtpPacket(new rtp_js_1.RtpHeader({
+        payloadType,
+        marker: packet.header.marker,
+        sequenceNumber,
+        timestamp: packet.header.timestamp,
+        ssrc,
+        csrc: packet.header.csrc,
+        extensions: packet.header.extensions
+    }), Buffer.concat([originalSequence, packet.payload]));
+    return rtx;
+}

package/dist/cjs/lib/rtp/srtp/cipher/ctr.d.ts

@@ -0,0 +1,16 @@
+import { CipherAesBase } from './index.js';
+import type { RtcpHeader } from '../../rtcp/header.js';
+import type { RtpHeader } from '../../rtp/rtp.js';
+export declare class CipherAesCtr extends CipherAesBase {
+    private srtpSessionAuthTag;
+    private srtcpSessionAuthTag;
+    readonly authTagLength = 10;
+    constructor(srtpSessionKey: Buffer, srtpSessionSalt: Buffer, srtcpSessionKey: Buffer, srtcpSessionSalt: Buffer, srtpSessionAuthTag: Buffer, srtcpSessionAuthTag: Buffer);
+    encryptRtp(header: RtpHeader, payload: Buffer, rolloverCounter: number): Buffer<ArrayBuffer>;
+    decryptRtp(cipherText: Buffer, rolloverCounter: number, header?: RtpHeader): [Buffer, RtpHeader];
+    encryptRTCP(rtcpPacket: Buffer, srtcpIndex: number): Buffer;
+    decryptRTCP(encrypted: Buffer): [Buffer, RtcpHeader];
+    generateSrtcpAuthTag(buf: Buffer): Buffer<ArrayBuffer>;
+    generateCounter(sequenceNumber: number, rolloverCounter: number, ssrc: number, sessionSalt: Buffer): Buffer<ArrayBuffer>;
+    generateSrtpAuthTag(roc: number, ...buffers: Buffer[]): Buffer<ArrayBuffer>;
+}

package/dist/cjs/lib/rtp/srtp/cipher/ctr.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CipherAesCtr = void 0;
+const node_crypto_1 = require("node:crypto");
+const index_js_1 = require("./index.js");
+const error_js_1 = require("../error.js");
+const packet_js_1 = require("../packet.js");
+class CipherAesCtr extends index_js_1.CipherAesBase {
+    constructor(srtpSessionKey, srtpSessionSalt, srtcpSessionKey, srtcpSessionSalt, srtpSessionAuthTag, srtcpSessionAuthTag) {
+        super(srtpSessionKey, srtpSessionSalt, srtcpSessionKey, srtcpSessionSalt);
+        this.srtpSessionAuthTag = srtpSessionAuthTag;
+        this.srtcpSessionAuthTag = srtcpSessionAuthTag;
+        this.authTagLength = 10;
+    }
+    encryptRtp(header, payload, rolloverCounter) {
+        const headerBuffer = header.serialize(header.serializeSize);
+        const counter = this.generateCounter(header.sequenceNumber, rolloverCounter, header.ssrc, this.srtpSessionSalt);
+        const cipher = (0, node_crypto_1.createCipheriv)('aes-128-ctr', this.srtpSessionKey, counter);
+        const enc = cipher.update(payload);
+        const authTag = this.generateSrtpAuthTag(rolloverCounter, headerBuffer, enc);
+        return Buffer.concat([headerBuffer, enc, authTag]);
+    }
+    decryptRtp(cipherText, rolloverCounter, header = (0, packet_js_1.parseSrtpRtpHeader)(cipherText, this.authTagLength)) {
+        const authTagOffset = cipherText.length - this.authTagLength;
+        const encryptedPacket = cipherText.subarray(0, authTagOffset);
+        const actualAuthTag = cipherText.subarray(authTagOffset);
+        const expectedAuthTag = this.generateSrtpAuthTag(rolloverCounter, encryptedPacket.subarray(0, header.payloadOffset), encryptedPacket.subarray(header.payloadOffset));
+        assertAuthTag(actualAuthTag, expectedAuthTag, 'Failed to authenticate SRTP packet');
+        const counter = this.generateCounter(header.sequenceNumber, rolloverCounter, header.ssrc, this.srtpSessionSalt);
+        const cipher = (0, node_crypto_1.createDecipheriv)('aes-128-ctr', this.srtpSessionKey, counter);
+        const payload = encryptedPacket.subarray(header.payloadOffset);
+        const buf = cipher.update(payload);
+        const dst = Buffer.concat([
+            encryptedPacket.subarray(0, header.payloadOffset),
+            buf
+        ]);
+        return [
+            dst,
+            (0, packet_js_1.finalizeSrtpRtpHeader)(header, dst, 'Failed to authenticate SRTP packet')
+        ];
+    }
+    encryptRTCP(rtcpPacket, srtcpIndex) {
+        let out = Buffer.from(rtcpPacket);
+        const ssrc = out.readUInt32BE(4);
+        const counter = this.generateCounter(srtcpIndex & 0xffff, srtcpIndex >> 16, ssrc, this.srtcpSessionSalt);
+        const cipher = (0, node_crypto_1.createCipheriv)('aes-128-ctr', this.srtcpSessionKey, counter);
+        // Encrypt everything after header
+        const buf = cipher.update(out.slice(8));
+        buf.copy(out, 8);
+        out = Buffer.concat([out, Buffer.alloc(4)]);
+        out.writeUInt32BE(srtcpIndex, out.length - 4);
+        out[out.length - 4] |= 0x80;
+        const authTag = this.generateSrtcpAuthTag(out);
+        out = Buffer.concat([out, authTag]);
+        return out;
+    }
+    decryptRTCP(encrypted) {
+        const header = (0, packet_js_1.parseSrtcpHeader)(encrypted, this.authTagLength, srtcpIndexSize);
+        const tailOffset = encrypted.length - (this.authTagLength + srtcpIndexSize);
+        const authenticatedPortion = encrypted.subarray(0, encrypted.length - this.authTagLength);
+        const actualTag = encrypted.subarray(encrypted.length - this.authTagLength);
+        const expectedTag = this.generateSrtcpAuthTag(authenticatedPortion);
+        assertAuthTag(actualTag, expectedTag, 'Failed to authenticate SRTCP packet');
+        const out = Buffer.from(encrypted).slice(0, tailOffset);
+        const isEncrypted = encrypted[tailOffset] >>> 7;
+        if (isEncrypted === 0)
+            return [out, header];
+        let srtcpIndex = encrypted.readUInt32BE(tailOffset);
+        srtcpIndex &= ~(1 << 31);
+        const ssrc = encrypted.readUInt32BE(4);
+        const counter = this.generateCounter(srtcpIndex & 0xffff, srtcpIndex >> 16, ssrc, this.srtcpSessionSalt);
+        const cipher = (0, node_crypto_1.createDecipheriv)('aes-128-ctr', this.srtcpSessionKey, counter);
+        const buf = cipher.update(out.subarray(8));
+        buf.copy(out, 8);
+        return [out, header];
+    }
+    generateSrtcpAuthTag(buf) {
+        const srtcpSessionAuth = (0, node_crypto_1.createHmac)('sha1', this.srtcpSessionAuthTag);
+        return srtcpSessionAuth.update(buf).digest().slice(0, 10);
+    }
+    generateCounter(sequenceNumber, rolloverCounter, ssrc, sessionSalt) {
+        const counter = Buffer.alloc(16);
+        counter.writeUInt32BE(ssrc, 4);
+        counter.writeUInt32BE(rolloverCounter, 8);
+        counter.writeUInt32BE(Number(BigInt(sequenceNumber) << 16n), 12);
+        for (let i = 0; i < sessionSalt.length; i++) {
+            counter[i] ^= sessionSalt[i];
+        }
+        return counter;
+    }
+    generateSrtpAuthTag(roc, ...buffers) {
+        const srtpSessionAuth = (0, node_crypto_1.createHmac)('sha1', this.srtpSessionAuthTag);
+        const rocRaw = Buffer.alloc(4);
+        rocRaw.writeUInt32BE(roc);
+        for (const buf of buffers) {
+            srtpSessionAuth.update(buf);
+        }
+        return srtpSessionAuth.update(rocRaw).digest().subarray(0, 10);
+    }
+}
+exports.CipherAesCtr = CipherAesCtr;
+const srtcpIndexSize = 4;
+function assertAuthTag(actual, expected, message) {
+    if (actual.length !== expected.length || !(0, node_crypto_1.timingSafeEqual)(actual, expected)) {
+        throw new error_js_1.SrtpAuthenticationError(message);
+    }
+}

package/dist/cjs/lib/rtp/srtp/cipher/gcm.d.ts

@@ -0,0 +1,17 @@
+import { CipherAesBase } from './index.js';
+import type { RtcpHeader } from '../../rtcp/header.js';
+import type { RtpHeader } from '../../rtp/rtp.js';
+export declare class CipherAesGcm extends CipherAesBase {
+    readonly aeadAuthTagLen = 16;
+    readonly rtpIvWriter: (values: (number | bigint)[]) => Buffer<ArrayBuffer>;
+    readonly rtcpIvWriter: (values: (number | bigint)[]) => Buffer<ArrayBuffer>;
+    readonly aadWriter: (values: (number | bigint)[]) => Buffer<ArrayBuffer>;
+    constructor(srtpSessionKey: Buffer, srtpSessionSalt: Buffer, srtcpSessionKey: Buffer, srtcpSessionSalt: Buffer);
+    encryptRtp(header: RtpHeader, payload: Buffer, rolloverCounter: number): Buffer<ArrayBuffer>;
+    decryptRtp(cipherText: Buffer, rolloverCounter: number, header?: RtpHeader): [Buffer, RtpHeader];
+    encryptRTCP(rtcpPacket: Buffer, srtcpIndex: number): Buffer;
+    decryptRTCP(encrypted: Buffer): [Buffer, RtcpHeader];
+    private rtpInitializationVector;
+    private rtcpInitializationVector;
+    private rtcpAdditionalAuthenticatedData;
+}

package/dist/cjs/lib/rtp/srtp/cipher/gcm.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CipherAesGcm = void 0;
+const node_crypto_1 = require("node:crypto");
+const index_js_1 = require("./index.js");
+const index_js_2 = require("../../../common/index.js");
+const helper_js_1 = require("../../helper.js");
+const error_js_1 = require("../error.js");
+const packet_js_1 = require("../packet.js");
+class CipherAesGcm extends index_js_1.CipherAesBase {
+    constructor(srtpSessionKey, srtpSessionSalt, srtcpSessionKey, srtcpSessionSalt) {
+        super(srtpSessionKey, srtpSessionSalt, srtcpSessionKey, srtcpSessionSalt);
+        this.aeadAuthTagLen = 16;
+        this.rtpIvWriter = (0, index_js_2.createBufferWriter)([2, 4, 4, 2], true);
+        this.rtcpIvWriter = (0, index_js_2.createBufferWriter)([2, 4, 2, 4], true);
+        this.aadWriter = (0, index_js_2.createBufferWriter)([4], true);
+    }
+    encryptRtp(header, payload, rolloverCounter) {
+        const hdr = header.serialize(header.serializeSize);
+        const iv = this.rtpInitializationVector(header, rolloverCounter);
+        const cipher = (0, node_crypto_1.createCipheriv)('aes-128-gcm', this.srtpSessionKey, iv);
+        cipher.setAAD(hdr);
+        const enc = cipher.update(payload);
+        cipher.final();
+        const authTag = cipher.getAuthTag();
+        const dst = Buffer.concat([hdr, enc, authTag]);
+        return dst;
+    }
+    decryptRtp(cipherText, rolloverCounter, header = (0, packet_js_1.parseSrtpRtpHeader)(cipherText, this.aeadAuthTagLen)) {
+        const headerBuffer = cipherText.subarray(0, header.payloadOffset);
+        const authTagOffset = cipherText.length - this.aeadAuthTagLen;
+        const authTag = cipherText.subarray(authTagOffset);
+        let dst = Buffer.from([]);
+        dst = (0, helper_js_1.growBufferSize)(dst, cipherText.length - this.aeadAuthTagLen);
+        headerBuffer.copy(dst);
+        const iv = this.rtpInitializationVector(header, rolloverCounter);
+        const enc = cipherText.slice(header.payloadOffset, authTagOffset);
+        const decipher = (0, node_crypto_1.createDecipheriv)('aes-128-gcm', this.srtpSessionKey, iv);
+        decipher.setAAD(headerBuffer);
+        decipher.setAuthTag(authTag);
+        const dec = decipher.update(enc);
+        finalizeAuthenticatedDecryption(decipher, 'SRTP');
+        dec.copy(dst, header.payloadOffset);
+        return [
+            dst,
+            (0, packet_js_1.finalizeSrtpRtpHeader)(header, dst, 'Failed to authenticate SRTP packet')
+        ];
+    }
+    encryptRTCP(rtcpPacket, srtcpIndex) {
+        const ssrc = rtcpPacket.readUInt32BE(4);
+        const addPos = rtcpPacket.length + this.aeadAuthTagLen;
+        let dst = Buffer.from([]);
+        dst = (0, helper_js_1.growBufferSize)(dst, addPos + srtcpIndexSize);
+        rtcpPacket.slice(0, 8).copy(dst);
+        const iv = this.rtcpInitializationVector(ssrc, srtcpIndex);
+        const aad = this.rtcpAdditionalAuthenticatedData(rtcpPacket, srtcpIndex);
+        const cipher = (0, node_crypto_1.createCipheriv)('aes-128-gcm', this.srtcpSessionKey, iv);
+        cipher.setAAD(aad);
+        const enc = cipher.update(rtcpPacket.slice(8));
+        cipher.final();
+        enc.copy(dst, 8);
+        const authTag = cipher.getAuthTag();
+        authTag.copy(dst, 8 + enc.length);
+        aad.slice(8, 12).copy(dst, addPos);
+        return dst;
+    }
+    decryptRTCP(encrypted) {
+        const header = (0, packet_js_1.parseSrtcpHeader)(encrypted, this.aeadAuthTagLen, srtcpIndexSize);
+        const srtcpIndexOffset = encrypted.length - srtcpIndexSize;
+        const authTagOffset = srtcpIndexOffset - this.aeadAuthTagLen;
+        const ssrc = encrypted.readUInt32BE(4);
+        const encodedSrtcpIndex = encrypted.readUInt32BE(srtcpIndexOffset);
+        const isEncrypted = encodedSrtcpIndex >>> 31 === 1;
+        const srtcpIndex = encodedSrtcpIndex & ~(rtcpEncryptionFlag << 24);
+        const iv = this.rtcpInitializationVector(ssrc, srtcpIndex);
+        const aad = isEncrypted
+            ? Buffer.concat([
+                encrypted.subarray(0, 8),
+                encrypted.subarray(srtcpIndexOffset)
+            ])
+            : Buffer.concat([
+                encrypted.subarray(0, authTagOffset),
+                encrypted.subarray(srtcpIndexOffset)
+            ]);
+        const cipherText = isEncrypted
+            ? encrypted.slice(8, authTagOffset)
+            : Buffer.alloc(0);
+        const dst = isEncrypted
+            ? Buffer.alloc(authTagOffset)
+            : Buffer.from(encrypted.subarray(0, authTagOffset));
+        if (isEncrypted) {
+            encrypted.slice(0, 8).copy(dst);
+        }
+        const decipher = (0, node_crypto_1.createDecipheriv)('aes-128-gcm', this.srtcpSessionKey, iv);
+        decipher.setAAD(aad);
+        decipher.setAuthTag(encrypted.subarray(authTagOffset, srtcpIndexOffset));
+        const dec = decipher.update(cipherText);
+        finalizeAuthenticatedDecryption(decipher, 'SRTCP');
+        if (isEncrypted) {
+            dec.copy(dst, 8);
+        }
+        return [dst, header];
+    }
+    // https://tools.ietf.org/html/rfc7714#section-8.1
+    rtpInitializationVector(header, rolloverCounter) {
+        const iv = this.rtpIvWriter([
+            0,
+            header.ssrc,
+            rolloverCounter,
+            header.sequenceNumber
+        ]);
+        for (let i = 0; i < iv.length; i++) {
+            iv[i] ^= this.srtpSessionSalt[i];
+        }
+        return iv;
+    }
+    // https://tools.ietf.org/html/rfc7714#section-9.1
+    rtcpInitializationVector(ssrc, srtcpIndex) {
+        const iv = this.rtcpIvWriter([0, ssrc, 0, srtcpIndex]);
+        for (let i = 0; i < iv.length; i++) {
+            iv[i] ^= this.srtcpSessionSalt[i];
+        }
+        return iv;
+    }
+    // https://datatracker.ietf.org/doc/html/rfc7714#section-17
+    rtcpAdditionalAuthenticatedData(rtcpPacket, srtcpIndex) {
+        const aad = Buffer.concat([
+            rtcpPacket.subarray(0, 8),
+            this.aadWriter([srtcpIndex])
+        ]);
+        aad[8] |= rtcpEncryptionFlag;
+        return aad;
+    }
+}
+exports.CipherAesGcm = CipherAesGcm;
+const srtcpIndexSize = 4;
+const rtcpEncryptionFlag = 0x80;
+function finalizeAuthenticatedDecryption(decipher, packetType) {
+    try {
+        decipher.final();
+    }
+    catch {
+        throw new error_js_1.SrtpAuthenticationError(`Failed to authenticate ${packetType} packet`);
+    }
+}

package/dist/cjs/lib/rtp/srtp/cipher/index.d.ts

@@ -0,0 +1,13 @@
+import type { RtcpHeader } from '../../rtcp/header.js';
+import type { RtpHeader } from '../../rtp/rtp.js';
+export declare abstract class CipherAesBase {
+    srtpSessionKey: Buffer;
+    srtpSessionSalt: Buffer;
+    srtcpSessionKey: Buffer;
+    srtcpSessionSalt: Buffer;
+    constructor(srtpSessionKey: Buffer, srtpSessionSalt: Buffer, srtcpSessionKey: Buffer, srtcpSessionSalt: Buffer);
+    encryptRtp(_header: RtpHeader, _payload: Buffer, _rolloverCounter: number): Buffer;
+    decryptRtp(_cipherText: Buffer, _rolloverCounter: number, _header?: RtpHeader): [Buffer, RtpHeader];
+    encryptRTCP(_rawRtcp: Buffer, _srtcpIndex: number): Buffer;
+    decryptRTCP(_encrypted: Buffer): [Buffer, RtcpHeader];
+}

package/dist/cjs/lib/rtp/srtp/cipher/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CipherAesBase = void 0;
+class CipherAesBase {
+    constructor(srtpSessionKey, srtpSessionSalt, srtcpSessionKey, srtcpSessionSalt) {
+        this.srtpSessionKey = srtpSessionKey;
+        this.srtpSessionSalt = srtpSessionSalt;
+        this.srtcpSessionKey = srtcpSessionKey;
+        this.srtcpSessionSalt = srtcpSessionSalt;
+    }
+    encryptRtp(_header, _payload, _rolloverCounter) {
+        return Buffer.from([]);
+    }
+    decryptRtp(_cipherText, _rolloverCounter, _header) {
+        return [];
+    }
+    encryptRTCP(_rawRtcp, _srtcpIndex) {
+        return Buffer.from([]);
+    }
+    decryptRTCP(_encrypted) {
+        return [];
+    }
+}
+exports.CipherAesBase = CipherAesBase;

package/dist/cjs/lib/rtp/srtp/const.d.ts

@@ -0,0 +1,6 @@
+export declare const ProtectionProfileAes128CmHmacSha1_80: 1;
+export declare const ProtectionProfileAeadAes128Gcm: 7;
+export declare const Profiles: readonly [1, 7];
+export type SrtpProfile = (typeof Profiles)[number];
+export declare const keyLength: (profile: SrtpProfile) => number;
+export declare const saltLength: (profile: SrtpProfile) => 12 | 14;

package/dist/cjs/lib/rtp/srtp/const.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saltLength = exports.keyLength = exports.Profiles = exports.ProtectionProfileAeadAes128Gcm = exports.ProtectionProfileAes128CmHmacSha1_80 = void 0;
+exports.ProtectionProfileAes128CmHmacSha1_80 = 0x0001;
+exports.ProtectionProfileAeadAes128Gcm = 0x0007;
+exports.Profiles = [
+    exports.ProtectionProfileAes128CmHmacSha1_80,
+    exports.ProtectionProfileAeadAes128Gcm
+];
+const keyLength = (profile) => {
+    switch (profile) {
+        case exports.ProtectionProfileAes128CmHmacSha1_80:
+        case exports.ProtectionProfileAeadAes128Gcm:
+            return 16;
+    }
+};
+exports.keyLength = keyLength;
+const saltLength = (profile) => {
+    switch (profile) {
+        case exports.ProtectionProfileAes128CmHmacSha1_80:
+            return 14;
+        case exports.ProtectionProfileAeadAes128Gcm:
+            return 12;
+    }
+};
+exports.saltLength = saltLength;