@lakutata/webrtc 0.0.0-stage → 3.1.4

package/dist/esm/lib/rtp/rtp/red/handler.js

@@ -0,0 +1,55 @@
+import { RtpHeader, RtpPacket, uint16Add, uint32Add } from '../../index.js';
+// 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
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |F|   block PT  |  timestamp offset         |   block length    |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// 0 1 2 3 4 5 6 7
+// +-+-+-+-+-+-+-+-+
+// |0|   Block PT  |
+// +-+-+-+-+-+-+-+-+
+export class RedHandler {
+    constructor() {
+        this.size = 150;
+        this.sequenceNumbers = [];
+    }
+    push(red, base) {
+        const packets = [];
+        red.blocks.forEach(({ blockPT, timestampOffset, block }, i) => {
+            const sequenceNumber = uint16Add(base.header.sequenceNumber, -(red.blocks.length - (i + 1)));
+            if (timestampOffset) {
+                packets.push(new RtpPacket(new RtpHeader({
+                    timestamp: uint32Add(base.header.timestamp, -timestampOffset),
+                    payloadType: blockPT,
+                    ssrc: base.header.ssrc,
+                    sequenceNumber,
+                    marker: true
+                }), block));
+            }
+            else {
+                packets.push(new RtpPacket(new RtpHeader({
+                    timestamp: base.header.timestamp,
+                    payloadType: blockPT,
+                    ssrc: base.header.ssrc,
+                    sequenceNumber,
+                    marker: true
+                }), block));
+            }
+        });
+        const filtered = packets.filter((p) => {
+            // duplicate
+            if (this.sequenceNumbers.includes(p.header.sequenceNumber)) {
+                return false;
+            }
+            else {
+                // buffer overflow
+                if (this.sequenceNumbers.length > this.size) {
+                    this.sequenceNumbers.shift();
+                }
+                this.sequenceNumbers.push(p.header.sequenceNumber);
+                return true;
+            }
+        });
+        return filtered;
+    }
+}

package/dist/esm/lib/rtp/rtp/red/packet.js

@@ -0,0 +1,107 @@
+// rfc2198
+import { BitStream, debug } from '../../imports/common.js';
+const log = debug('packages/rtp/src/rtp/red/packet.ts');
+// 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
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |F|   block PT  |  timestamp offset         |   block length    |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// 0 1 2 3 4 5 6 7
+// +-+-+-+-+-+-+-+-+
+// |0|   Block PT  |
+// +-+-+-+-+-+-+-+-+
+export class Red {
+    constructor() {
+        this.blocks = [];
+    }
+    static deSerialize(bufferOrArrayBuffer) {
+        const buf = bufferOrArrayBuffer instanceof ArrayBuffer
+            ? Buffer.from(bufferOrArrayBuffer)
+            : bufferOrArrayBuffer;
+        const red = new Red();
+        let offset = 0;
+        [red.header, offset] = RedHeader.deSerialize(buf);
+        red.header.fields.forEach(({ blockLength, timestampOffset, blockPT }) => {
+            if (blockLength && timestampOffset) {
+                const block = buf.subarray(offset, offset + blockLength);
+                red.blocks.push({ block, blockPT, timestampOffset });
+                offset += blockLength;
+            }
+            else {
+                const block = buf.subarray(offset);
+                red.blocks.push({ block, blockPT });
+            }
+        });
+        return red;
+    }
+    serialize() {
+        this.header = new RedHeader();
+        for (const { timestampOffset, blockPT, block } of this.blocks) {
+            if (timestampOffset) {
+                this.header.fields.push({
+                    fBit: 1,
+                    blockPT,
+                    blockLength: block.length,
+                    timestampOffset
+                });
+            }
+            else {
+                this.header.fields.push({ fBit: 0, blockPT });
+            }
+        }
+        let buf = this.header.serialize();
+        for (const { block } of this.blocks) {
+            buf = Buffer.concat([buf, block]);
+        }
+        return buf;
+    }
+}
+export class RedHeader {
+    constructor() {
+        this.fields = [];
+    }
+    static deSerialize(buf) {
+        let offset = 0;
+        const header = new RedHeader();
+        for (;;) {
+            const field = {};
+            header.fields.push(field);
+            const bitStream = new BitStream(buf.subarray(offset));
+            field.fBit = bitStream.readBits(1);
+            field.blockPT = bitStream.readBits(7);
+            offset++;
+            if (field.fBit === 0) {
+                break;
+            }
+            field.timestampOffset = bitStream.readBits(14);
+            field.blockLength = bitStream.readBits(10);
+            offset += 3;
+        }
+        return [header, offset];
+    }
+    serialize() {
+        let buf = Buffer.alloc(0);
+        for (const field of this.fields) {
+            try {
+                if (field.timestampOffset && field.blockLength) {
+                    const bitStream = new BitStream(Buffer.alloc(4))
+                        .writeBits(1, field.fBit)
+                        .writeBits(7, field.blockPT)
+                        .writeBits(14, field.timestampOffset)
+                        .writeBits(10, field.blockLength);
+                    buf = Buffer.concat([buf, bitStream.uint8Array]);
+                }
+                else {
+                    const bitStream = new BitStream(Buffer.alloc(1))
+                        .writeBits(1, 0)
+                        .writeBits(7, field.blockPT);
+                    buf = Buffer.concat([buf, bitStream.uint8Array]);
+                }
+            }
+            catch (error) {
+                log(error?.message);
+            }
+        }
+        return buf;
+    }
+}

package/dist/esm/lib/rtp/rtp/rtp.js

@@ -0,0 +1,266 @@
+import { BitWriter, getBit } from '../../common/index.js';
+export const 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             |
+ * |                             ....                              |
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ */
+export 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 = 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 = getBit(v_p_x_cc, 0, 2);
+        h.padding = getBit(v_p_x_cc, 2) > 0;
+        h.extension = getBit(v_p_x_cc, 3) > 0;
+        h.csrcLength = 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 = getBit(m_pt, 0) > 0;
+        h.payloadType = 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 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 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 ExtensionProfiles.OneByte:
+                    for (const extension of extensions) {
+                        extSize += 1 + extension.payload.length;
+                    }
+                    break;
+                case 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 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 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 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 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;
+    }
+}
+export 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;
+    }
+}

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

@@ -0,0 +1,25 @@
+import { RtpHeader, RtpPacket } from './rtp.js';
+export function unwrapRtx(rtx, payloadType, ssrc) {
+    const packet = new RtpPacket(new RtpHeader({
+        payloadType,
+        marker: rtx.header.marker,
+        sequenceNumber: rtx.payload.readUInt16BE(0),
+        timestamp: rtx.header.timestamp,
+        ssrc
+    }), rtx.payload.subarray(2));
+    return packet;
+}
+export function wrapRtx(packet, payloadType, sequenceNumber, ssrc) {
+    const originalSequence = Buffer.allocUnsafe(2);
+    originalSequence.writeUInt16BE(packet.header.sequenceNumber, 0);
+    const rtx = new RtpPacket(new 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/esm/lib/rtp/srtp/cipher/ctr.js

@@ -0,0 +1,103 @@
+import { createCipheriv, createDecipheriv, createHmac, timingSafeEqual } from 'node:crypto';
+import { CipherAesBase } from './index.js';
+import { SrtpAuthenticationError } from '../error.js';
+import { finalizeSrtpRtpHeader, parseSrtcpHeader, parseSrtpRtpHeader } from '../packet.js';
+export class CipherAesCtr extends 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 = 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 = 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 = 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,
+            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 = 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 = 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 = 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 = 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 = 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);
+    }
+}
+const srtcpIndexSize = 4;
+function assertAuthTag(actual, expected, message) {
+    if (actual.length !== expected.length || !timingSafeEqual(actual, expected)) {
+        throw new SrtpAuthenticationError(message);
+    }
+}