@lakutata/webrtc 0.0.0-stage → 3.1.1

package/dist/esm/lib/turn/protocol.js

@@ -0,0 +1,112 @@
+import { classes, isComprehensionRequiredAttribute, isStunMessage, methods } from './stun/const.js';
+import { Message, parseMessage } from './stun/message.js';
+export class StunServerProtocol {
+    constructor(options = {}) {
+        this.software = options.software;
+        this.fingerprint = options.fingerprint ?? 'if-present';
+        this.authenticateRequest = options.authenticateRequest;
+    }
+    handleDatagram(input) {
+        if (!isStunMessage(input.data)) {
+            return [
+                {
+                    type: 'ignore',
+                    reason: 'non-stun'
+                }
+            ];
+        }
+        const request = parseMessage(input.data);
+        if (!request) {
+            return [
+                {
+                    type: 'ignore',
+                    reason: 'malformed'
+                }
+            ];
+        }
+        if (request.messageClass === classes.INDICATION) {
+            return [
+                {
+                    type: 'ignore',
+                    reason: 'binding-indication'
+                }
+            ];
+        }
+        if (request.messageClass !== classes.REQUEST) {
+            return [
+                {
+                    type: 'ignore',
+                    reason: 'non-request'
+                }
+            ];
+        }
+        const context = {
+            ...input,
+            message: request
+        };
+        const unknownAttributes = [
+            ...new Set(request.unknownAttributeTypes.filter(isComprehensionRequiredAttribute))
+        ].sort((left, right) => left - right);
+        if (unknownAttributes.length > 0) {
+            return [
+                this.sendAction(this.errorResponse(context, 420, 'Unknown Attribute', [
+                    ['UNKNOWN-ATTRIBUTES', unknownAttributes]
+                ]), input.remoteAddress)
+            ];
+        }
+        if (request.messageMethod !== methods.BINDING) {
+            return [
+                this.sendAction(this.errorResponse(context, 400, 'Bad Request'), input.remoteAddress)
+            ];
+        }
+        const authResult = this.authenticateRequest?.(context);
+        if (authResult?.ok === false) {
+            return [
+                this.sendAction(this.errorResponse(context, authResult.errorCode, authResult.reason, authResult.attributes), input.remoteAddress)
+            ];
+        }
+        return [
+            this.sendAction(this.successResponse(context, authResult?.attributes), input.remoteAddress)
+        ];
+    }
+    sendAction(message, remoteAddress) {
+        return {
+            type: 'send',
+            data: message.bytes,
+            remoteAddress
+        };
+    }
+    successResponse(context, attributes = []) {
+        const response = new Message(methods.BINDING, classes.RESPONSE, context.message.transactionId);
+        response.setAttribute('XOR-MAPPED-ADDRESS', context.remoteAddress);
+        this.addDefaultAttributes(response, context, attributes);
+        return response;
+    }
+    errorResponse(context, errorCode, reason, attributes = []) {
+        const response = new Message(context.message.messageMethod, classes.ERROR, context.message.transactionId);
+        response.setAttribute('ERROR-CODE', [errorCode, reason]);
+        this.addDefaultAttributes(response, context, attributes);
+        return response;
+    }
+    addDefaultAttributes(response, context, attributes) {
+        for (const [key, value] of attributes) {
+            response.setAttribute(key, value);
+        }
+        if (this.software) {
+            response.setAttribute('SOFTWARE', this.software);
+        }
+        if (this.shouldAddFingerprint(context.message)) {
+            response.addFingerprint();
+        }
+    }
+    shouldAddFingerprint(request) {
+        switch (this.fingerprint) {
+            case 'always':
+                return true;
+            case 'if-present':
+                return request.getAttributeValue('FINGERPRINT') !== undefined;
+            default:
+                return false;
+        }
+    }
+}

package/dist/esm/lib/turn/stun/attributes.js

@@ -0,0 +1,198 @@
+import { COOKIE, IPV4_PROTOCOL, IPV6_PROTOCOL } from './const.js';
+import { bufferToIpAddress, ipAddressToBuffer, isIpV4Address } from './ip.js';
+function packAddress(value) {
+    const [address] = value;
+    const protocol = isIpV4Address(address) ? IPV4_PROTOCOL : IPV6_PROTOCOL;
+    const buffer = Buffer.alloc(4);
+    buffer.writeUInt8(0, 0);
+    buffer.writeUInt8(protocol, 1);
+    buffer.writeUInt16BE(value[1], 2);
+    return Buffer.concat([buffer, ipAddressToBuffer(address)]);
+}
+export function unpackErrorCode(data) {
+    if (data.length < 4) {
+        throw new Error('STUN error code is less than 4 bytes');
+    }
+    const codeHigh = data.readUInt8(2);
+    const codeLow = data.readUInt8(3);
+    const reason = data.slice(4).toString('utf8');
+    return [codeHigh * 100 + codeLow, reason];
+}
+function unpackAddress(data) {
+    if (data.length < 4) {
+        throw new Error('STUN address length is less than 4 bytes');
+    }
+    const protocol = data.readUInt8(1);
+    const port = data.readUInt16BE(2);
+    const address = data.slice(4);
+    switch (protocol) {
+        case IPV4_PROTOCOL:
+            if (address.length !== 4) {
+                throw new Error('STUN address has invalid length for IPv4');
+            }
+            return [bufferToIpAddress(address), port];
+        case IPV6_PROTOCOL:
+            if (address.length !== 16) {
+                throw new Error('STUN address has invalid length for IPv6');
+            }
+            return [bufferToIpAddress(address), port];
+        default:
+            throw new Error('STUN address has unknown protocol');
+    }
+}
+const cookieBuffer = Buffer.alloc(6);
+cookieBuffer.writeUInt16BE(COOKIE >> 16, 0);
+cookieBuffer.writeUInt32BE(COOKIE, 2);
+function xorAddress(data, transactionId) {
+    const xPad = [...cookieBuffer, ...transactionId];
+    let xData = data.slice(0, 2);
+    for (let i = 2; i < data.length; i++) {
+        const num = data[i] ^ xPad[i - 2];
+        const buf = Buffer.alloc(1);
+        buf.writeUIntBE(num, 0, 1);
+        xData = Buffer.concat([xData, buf]);
+    }
+    return xData;
+}
+export function unpackXorAddress(data, transactionId) {
+    return unpackAddress(xorAddress(data, transactionId));
+}
+export function packErrorCode(value) {
+    const buffer = Buffer.alloc(4);
+    buffer.writeUInt16BE(0, 0);
+    buffer.writeUInt8(Math.floor(value[0] / 100), 2);
+    buffer.writeUInt8(value[0] % 100, 3);
+    const encoded = Buffer.from(value[1], 'utf8');
+    return Buffer.concat([buffer, encoded]);
+}
+export function packUnknownAttributes(value) {
+    const buffer = Buffer.alloc(value.length * 2);
+    value.forEach((attributeType, index) => {
+        buffer.writeUInt16BE(attributeType, index * 2);
+    });
+    return buffer;
+}
+export function unpackUnknownAttributes(data) {
+    if (data.length % 2 !== 0) {
+        throw new Error('UNKNOWN-ATTRIBUTES must have an even length');
+    }
+    const attributes = [];
+    for (let offset = 0; offset < data.length; offset += 2) {
+        attributes.push(data.readUInt16BE(offset));
+    }
+    return attributes;
+}
+export function packXorAddress(value, transactionId) {
+    return xorAddress(packAddress(value), transactionId);
+}
+const packUnsigned = (value) => {
+    const buffer = Buffer.alloc(4);
+    buffer.writeUInt32BE(value, 0);
+    return buffer;
+};
+const unpackUnsigned = (data) => data.readUInt32BE(0);
+const packUnsignedShort = (value) => {
+    const buffer = Buffer.alloc(4);
+    buffer.writeUInt16BE(value, 0);
+    return buffer;
+};
+const unpackUnsignedShort = (data) => data.readUInt16BE(0);
+const packUnsigned64 = (value) => {
+    const buffer = Buffer.allocUnsafe(8);
+    buffer.writeBigUInt64BE(value, 0);
+    return buffer;
+};
+const unpackUnsigned64 = (data) => data.readBigUInt64BE(0);
+const packString = (value) => Buffer.from(value, 'utf8');
+const unpackString = (data) => data.toString('utf8');
+const packSoftware = (value) => {
+    if ([...value].length >= 128) {
+        throw new Error('SOFTWARE must be shorter than 128 characters');
+    }
+    return packString(value);
+};
+const packBytes = (value) => value;
+const unpackBytes = (data) => data;
+const packNone = () => Buffer.alloc(0);
+const unpackNone = () => null;
+const ATTRIBUTES = [
+    [0x0001, 'MAPPED-ADDRESS', packAddress, unpackAddress],
+    [0x0003, 'CHANGE-REQUEST', packUnsigned, unpackUnsigned],
+    [0x0004, 'SOURCE-ADDRESS', packAddress, unpackAddress],
+    [0x0005, 'CHANGED-ADDRESS', packAddress, unpackAddress],
+    [0x0006, 'USERNAME', packString, unpackString],
+    [0x0008, 'MESSAGE-INTEGRITY', packBytes, unpackBytes],
+    [0x0009, 'ERROR-CODE', packErrorCode, unpackErrorCode],
+    [
+        0x000a,
+        'UNKNOWN-ATTRIBUTES',
+        packUnknownAttributes,
+        unpackUnknownAttributes
+    ],
+    [0x000c, 'CHANNEL-NUMBER', packUnsignedShort, unpackUnsignedShort],
+    [0x000d, 'LIFETIME', packUnsigned, unpackUnsigned],
+    [0x0012, 'XOR-PEER-ADDRESS', packXorAddress, unpackXorAddress],
+    [0x0013, 'DATA', packBytes, unpackBytes],
+    [0x0014, 'REALM', packString, unpackString],
+    [0x0015, 'NONCE', packBytes, unpackBytes],
+    [0x0016, 'XOR-RELAYED-ADDRESS', packXorAddress, unpackXorAddress],
+    [0x0017, 'REQUESTED-ADDRESS-FAMILY', packUnsigned, unpackUnsigned],
+    [0x0018, 'EVEN-PORT', packBytes, unpackBytes],
+    [0x0019, 'REQUESTED-TRANSPORT', packUnsigned, unpackUnsigned],
+    [0x001c, 'MESSAGE-INTEGRITY-SHA256', packBytes, unpackBytes],
+    [0x001d, 'PASSWORD-ALGORITHM', packBytes, unpackBytes],
+    [0x001e, 'USERHASH', packBytes, unpackBytes],
+    [0x0020, 'XOR-MAPPED-ADDRESS', packXorAddress, unpackXorAddress],
+    [0x0022, 'RESERVATION-TOKEN', packBytes, unpackBytes],
+    [0x0024, 'PRIORITY', packUnsigned, unpackUnsigned],
+    [0x0025, 'USE-CANDIDATE', packNone, unpackNone],
+    [0x8002, 'PASSWORD-ALGORITHMS', packBytes, unpackBytes],
+    [0x8003, 'ALTERNATE-DOMAIN', packString, unpackString],
+    [0x8022, 'SOFTWARE', packSoftware, unpackString],
+    [0x8023, 'ALTERNATE-SERVER', packAddress, unpackAddress],
+    [0x8028, 'FINGERPRINT', packUnsigned, unpackUnsigned],
+    [0x8029, 'ICE-CONTROLLED', packUnsigned64, unpackUnsigned64],
+    [0x802a, 'ICE-CONTROLLING', packUnsigned64, unpackUnsigned64],
+    [0x802b, 'RESPONSE-ORIGIN', packAddress, unpackAddress],
+    [0x802c, 'OTHER-ADDRESS', packAddress, unpackAddress]
+];
+export class AttributeRepository {
+    constructor(attributes = []) {
+        this.attributes = attributes;
+    }
+    getAttributes() {
+        return this.attributes;
+    }
+    setAttribute(key, value) {
+        const existing = this.attributes.find((attribute) => attribute[0] === key);
+        if (existing) {
+            existing[1] = value;
+        }
+        else {
+            this.attributes.push([key, value]);
+        }
+        return this;
+    }
+    getAttributeValue(key) {
+        const attribute = this.attributes.find((candidate) => candidate[0] === key);
+        return attribute?.[1];
+    }
+    get attributesKeys() {
+        return this.attributes.map((attribute) => attribute[0]);
+    }
+    removeAttribute(key) {
+        this.attributes = this.attributes.filter((attribute) => attribute[0] !== key);
+        return this;
+    }
+    clear() {
+        this.attributes = [];
+    }
+}
+export const ATTRIBUTES_BY_TYPE = ATTRIBUTES.reduce((acc, cur) => {
+    acc[cur[0]] = cur;
+    return acc;
+}, {});
+export const ATTRIBUTES_BY_NAME = ATTRIBUTES.reduce((acc, cur) => {
+    acc[cur[1]] = cur;
+    return acc;
+}, {});

package/dist/esm/lib/turn/stun/const.js

@@ -0,0 +1,82 @@
+export const COOKIE = 0x2112a442;
+export const FINGERPRINT_LENGTH = 8;
+export const FINGERPRINT_XOR = 0x5354554e;
+export const HEADER_LENGTH = 20;
+export const INTEGRITY_LENGTH = 24;
+export const IPV4_PROTOCOL = 1;
+export const IPV6_PROTOCOL = 2;
+export const RETRY_MAX = 6;
+export const RETRY_RTO = 50;
+export const AttributeKeys = [
+    'FINGERPRINT',
+    'MESSAGE-INTEGRITY',
+    'MESSAGE-INTEGRITY-SHA256',
+    'CHANGE-REQUEST',
+    'PRIORITY',
+    'USERNAME',
+    'USERHASH',
+    'ICE-CONTROLLING',
+    'SOURCE-ADDRESS',
+    'USE-CANDIDATE',
+    'ICE-CONTROLLED',
+    'ERROR-CODE',
+    'UNKNOWN-ATTRIBUTES',
+    'XOR-MAPPED-ADDRESS',
+    'CHANGED-ADDRESS',
+    'LIFETIME',
+    'REQUESTED-TRANSPORT',
+    'NONCE',
+    'REALM',
+    'REQUESTED-ADDRESS-FAMILY',
+    'EVEN-PORT',
+    'PASSWORD-ALGORITHM',
+    'PASSWORD-ALGORITHMS',
+    'XOR-RELAYED-ADDRESS',
+    'RESERVATION-TOKEN',
+    'CHANNEL-NUMBER',
+    'XOR-PEER-ADDRESS',
+    'DATA',
+    'SOFTWARE',
+    'MAPPED-ADDRESS',
+    'ALTERNATE-DOMAIN',
+    'ALTERNATE-SERVER',
+    'RESPONSE-ORIGIN',
+    'OTHER-ADDRESS'
+];
+export var classes;
+(function (classes) {
+    classes[classes["REQUEST"] = 0] = "REQUEST";
+    classes[classes["INDICATION"] = 16] = "INDICATION";
+    classes[classes["RESPONSE"] = 256] = "RESPONSE";
+    classes[classes["ERROR"] = 272] = "ERROR";
+})(classes || (classes = {}));
+export var methods;
+(function (methods) {
+    methods[methods["BINDING"] = 1] = "BINDING";
+    methods[methods["SHARED_SECRET"] = 2] = "SHARED_SECRET";
+    methods[methods["ALLOCATE"] = 3] = "ALLOCATE";
+    methods[methods["REFRESH"] = 4] = "REFRESH";
+    methods[methods["SEND"] = 6] = "SEND";
+    methods[methods["DATA"] = 7] = "DATA";
+    methods[methods["CREATE_PERMISSION"] = 8] = "CREATE_PERMISSION";
+    methods[methods["CHANNEL_BIND"] = 9] = "CHANNEL_BIND";
+})(methods || (methods = {}));
+export function isComprehensionRequiredAttribute(type) {
+    return type >= 0x0000 && type <= 0x7fff;
+}
+export function isStunMessage(data) {
+    if (data.length < HEADER_LENGTH) {
+        return false;
+    }
+    if ((data[0] & 0xc0) !== 0) {
+        return false;
+    }
+    if (data.readUInt32BE(4) !== COOKIE) {
+        return false;
+    }
+    const length = data.readUInt16BE(2);
+    if (length % 4 !== 0) {
+        return false;
+    }
+    return data.length === HEADER_LENGTH + length;
+}

package/dist/esm/lib/turn/stun/ip.js

@@ -0,0 +1,81 @@
+import { isIPv4, isIPv6 } from 'node:net';
+/**
+ * Convert an IPv4 / IPv6 text address to the STUN wire binary form.
+ * IPv4 → 4 bytes, IPv6 → 16 bytes (supports :: compression and IPv4-mapped).
+ */
+export function ipAddressToBuffer(address) {
+    if (isIPv4(address)) {
+        const buf = Buffer.allocUnsafe(4);
+        const parts = address.split('.');
+        for (let i = 0; i < 4; i++) {
+            buf[i] = Number(parts[i]) & 0xff;
+        }
+        return buf;
+    }
+    if (!isIPv6(address)) {
+        throw new Error(`Invalid ip address: ${address}`);
+    }
+    const sections = address.split(':', 8);
+    for (let i = 0; i < sections.length; i++) {
+        let v4Buffer;
+        if (isIPv4(sections[i])) {
+            v4Buffer = ipAddressToBuffer(sections[i]);
+            sections[i] = v4Buffer.subarray(0, 2).toString('hex');
+        }
+        if (v4Buffer && ++i < 8) {
+            sections.splice(i, 0, v4Buffer.subarray(2, 4).toString('hex'));
+        }
+    }
+    if (sections[0] === '') {
+        while (sections.length < 8)
+            sections.unshift('0');
+    }
+    else if (sections[sections.length - 1] === '') {
+        while (sections.length < 8)
+            sections.push('0');
+    }
+    else if (sections.length < 8) {
+        let emptyIndex = 0;
+        for (; emptyIndex < sections.length && sections[emptyIndex] !== ''; emptyIndex++)
+            ;
+        const zeros = [];
+        for (let n = 9 - sections.length; n > 0; n--) {
+            zeros.push('0');
+        }
+        sections.splice(emptyIndex, 1, ...zeros);
+    }
+    const result = Buffer.allocUnsafe(16);
+    let offset = 0;
+    for (const section of sections) {
+        const word = Number.parseInt(section, 16) || 0;
+        result[offset++] = (word >> 8) & 0xff;
+        result[offset++] = word & 0xff;
+    }
+    return result;
+}
+/**
+ * Convert STUN address bytes (4 or 16) back to a text IP address.
+ * IPv6 uses the same zero-run compression style as the previous `ip` helper.
+ */
+export function bufferToIpAddress(buf) {
+    if (buf.length === 4) {
+        return `${buf[0]}.${buf[1]}.${buf[2]}.${buf[3]}`;
+    }
+    if (buf.length !== 16) {
+        throw new Error(`Invalid ip address buffer length: ${buf.length}`);
+    }
+    const hextets = [];
+    for (let i = 0; i < 16; i += 2) {
+        hextets.push(buf.readUInt16BE(i).toString(16));
+    }
+    let result = hextets.join(':');
+    result = result.replace(/(^|:)0(:0)*:0(:|$)/, '$1::$3');
+    result = result.replace(/:{3,4}/, '::');
+    return result;
+}
+export function isIpV4Address(address) {
+    return isIPv4(address);
+}
+export function isIpV6Address(address) {
+    return isIPv6(address);
+}

package/dist/esm/lib/turn/stun/message.js

@@ -0,0 +1,174 @@
+import { createHmac, randomBytes } from 'node:crypto';
+import { crc32 } from '../../common/index.js';
+import { ATTRIBUTES_BY_NAME, ATTRIBUTES_BY_TYPE, AttributeRepository, packXorAddress, unpackXorAddress } from './attributes.js';
+import { COOKIE, FINGERPRINT_LENGTH, FINGERPRINT_XOR, HEADER_LENGTH, INTEGRITY_LENGTH, isStunMessage } from './const.js';
+export function parseMessage(data, integrityKey) {
+    if (!isStunMessage(data)) {
+        return undefined;
+    }
+    const messageType = data.readUInt16BE(0);
+    const transactionId = Buffer.from(data.slice(HEADER_LENGTH - 12, HEADER_LENGTH));
+    const attributeRepository = new AttributeRepository();
+    const rawAttributes = [];
+    // When integrityKey is provided, MESSAGE-INTEGRITY must be present and valid
+    // (RFC 5389 short-term credentials / RFC 7675 authenticated consent responses).
+    let messageIntegrityVerified = false;
+    for (let pos = HEADER_LENGTH; pos < data.length;) {
+        if (pos + 4 > data.length) {
+            return undefined;
+        }
+        const attrType = data.readUInt16BE(pos);
+        const attrLen = data.readUInt16BE(pos + 2);
+        const valueStart = pos + 4;
+        const valueEnd = valueStart + attrLen;
+        if (valueEnd > data.length) {
+            return undefined;
+        }
+        const payload = data.slice(valueStart, valueEnd);
+        const padLen = paddingLength(attrLen);
+        if (valueEnd + padLen > data.length) {
+            return undefined;
+        }
+        const attribute = ATTRIBUTES_BY_TYPE[attrType];
+        if (attribute) {
+            const [, attrName, , attrUnpack] = attribute;
+            let value;
+            try {
+                value =
+                    attrUnpack.name === unpackXorAddress.name
+                        ? attrUnpack(payload, transactionId)
+                        : attrUnpack(payload);
+            }
+            catch {
+                return undefined;
+            }
+            attributeRepository.setAttribute(attrName, value);
+            if (attrName === 'FINGERPRINT') {
+                const fingerprint = messageFingerprint(data.slice(0, pos));
+                if (attributeRepository.getAttributeValue('FINGERPRINT') !== fingerprint) {
+                    return undefined;
+                }
+            }
+            else if (attrName === 'MESSAGE-INTEGRITY' && integrityKey) {
+                const integrity = messageIntegrity(data.slice(0, pos), integrityKey);
+                const expected = attributeRepository.getAttributeValue('MESSAGE-INTEGRITY');
+                if (!integrity.equals(expected)) {
+                    return undefined;
+                }
+                messageIntegrityVerified = true;
+            }
+        }
+        else {
+            rawAttributes.push({
+                type: attrType,
+                length: attrLen,
+                value: Buffer.from(payload)
+            });
+        }
+        pos = valueEnd + padLen;
+    }
+    // Reject unsigned messages when the caller required authentication.
+    if (integrityKey && !messageIntegrityVerified) {
+        return undefined;
+    }
+    return new Message(messageType & 0x3eef, messageType & 0x0110, transactionId, attributeRepository.getAttributes(), rawAttributes);
+}
+export class Message extends AttributeRepository {
+    constructor(messageMethod, messageClass, transactionId = randomBytes(12), attributes = [], rawAttributes = []) {
+        super(attributes);
+        this.messageMethod = messageMethod;
+        this.messageClass = messageClass;
+        this.transactionId = transactionId;
+        this.rawAttributes = rawAttributes;
+    }
+    toJSON() {
+        return this.json;
+    }
+    get json() {
+        return {
+            messageMethod: this.messageMethod,
+            messageClass: this.messageClass,
+            attributes: this.attributes,
+            rawAttributes: this.rawAttributes.map((attribute) => ({
+                type: attribute.type,
+                length: attribute.value.length
+            }))
+        };
+    }
+    get transactionIdHex() {
+        return this.transactionId.toString('hex');
+    }
+    appendRawAttribute(type, value) {
+        this.rawAttributes.push({ type, value: Buffer.from(value) });
+        return this;
+    }
+    get unknownAttributeTypes() {
+        return this.rawAttributes.map((attribute) => attribute.type);
+    }
+    get bytes() {
+        const body = Buffer.concat(this.serializedAttributes.map((attribute) => serializeAttribute(attribute.type, attribute.value)));
+        const header = Buffer.alloc(8);
+        header.writeUInt16BE(this.messageMethod | this.messageClass, 0);
+        header.writeUInt16BE(body.length, 2);
+        header.writeUInt32BE(COOKIE, 4);
+        return Buffer.concat([header, this.transactionId, body]);
+    }
+    addMessageIntegrity(key) {
+        //Signing again (a retry with a new nonce) replaces the integrity and the fingerprint after it
+        this.removeAttribute('FINGERPRINT').removeAttribute('MESSAGE-INTEGRITY');
+        this.setAttribute('MESSAGE-INTEGRITY', this.messageIntegrity(key));
+        return this;
+    }
+    messageIntegrity(key) {
+        const checkData = setBodyLength(this.bytes, this.bytes.length - HEADER_LENGTH + INTEGRITY_LENGTH);
+        return Buffer.from(createHmac('sha1', key).update(checkData).digest('hex'), 'hex');
+    }
+    addFingerprint() {
+        this.removeAttribute('FINGERPRINT');
+        this.setAttribute('FINGERPRINT', messageFingerprint(this.bytes));
+        return this;
+    }
+    get serializedAttributes() {
+        const attributes = [];
+        for (const attrName of this.attributesKeys) {
+            const attrValue = this.getAttributeValue(attrName);
+            const [attrType, , attrPack] = ATTRIBUTES_BY_NAME[attrName];
+            const value = attrPack.name === packXorAddress.name
+                ? attrPack(attrValue, this.transactionId)
+                : attrPack(attrValue);
+            attributes.push({ type: attrType, value });
+        }
+        attributes.push(...this.rawAttributes.map((attribute) => ({
+            type: attribute.type,
+            value: Buffer.from(attribute.value)
+        })));
+        return attributes;
+    }
+}
+function serializeAttribute(type, value) {
+    const attrLen = value.length;
+    const padLen = paddingLength(attrLen);
+    const header = Buffer.alloc(4);
+    header.writeUInt16BE(type, 0);
+    header.writeUInt16BE(attrLen, 2);
+    return Buffer.concat([header, value, Buffer.alloc(padLen)]);
+}
+const setBodyLength = (data, length) => {
+    const output = Buffer.alloc(data.length);
+    data.copy(output, 0, 0, 2);
+    output.writeUInt16BE(length, 2);
+    data.copy(output, 4, 4);
+    return output;
+};
+function messageFingerprint(data) {
+    const checkData = setBodyLength(data, data.length - HEADER_LENGTH + FINGERPRINT_LENGTH);
+    return (crc32(checkData) ^ FINGERPRINT_XOR) >>> 0;
+}
+function messageIntegrity(data, key) {
+    const checkData = setBodyLength(data, data.length - HEADER_LENGTH + INTEGRITY_LENGTH);
+    return Buffer.from(createHmac('sha1', key).update(checkData).digest('hex'), 'hex');
+}
+export function paddingLength(length) {
+    const rest = length % 4;
+    return rest === 0 ? 0 : 4 - rest;
+}

package/dist/esm/lib/turn/turn/auth.js

@@ -0,0 +1,6 @@
+import { createHash } from 'node:crypto';
+export function makeTurnIntegrityKey(username, realm, password) {
+    return createHash('md5')
+        .update(Buffer.from([username, realm, password].join(':')))
+        .digest();
+}