zapo-js 0.1.0

package/dist/esm/transport/node/query.js

@@ -0,0 +1,53 @@
+import { WA_IQ_TYPES, WA_NODE_TAGS } from '../../protocol/constants.js';
+import { findNodeChild } from '../node/helpers.js';
+import { toError } from '../../util/primitives.js';
+export function buildIqNode(type, to, xmlns, content, attrs = {}) {
+    return {
+        tag: WA_NODE_TAGS.IQ,
+        attrs: {
+            ...attrs,
+            to,
+            type,
+            xmlns
+        },
+        ...(content !== undefined ? { content } : {})
+    };
+}
+export function parseIqError(node) {
+    const errorNode = findNodeChild(node, WA_NODE_TAGS.ERROR);
+    const code = errorNode?.attrs.code ?? node.attrs.type ?? 'unknown';
+    const text = errorNode?.attrs.text ?? errorNode?.attrs.type ?? 'unknown';
+    const parsedCode = Number.parseInt(code, 10);
+    return {
+        code,
+        text,
+        ...(Number.isSafeInteger(parsedCode) ? { numericCode: parsedCode } : {})
+    };
+}
+export function assertIqResult(node, context) {
+    if (node.tag !== WA_NODE_TAGS.IQ) {
+        throw new Error(`${context} returned non-iq node (${node.tag})`);
+    }
+    if (node.attrs.type === WA_IQ_TYPES.RESULT) {
+        return;
+    }
+    const error = parseIqError(node);
+    throw new Error(`${context} iq failed (${error.code}: ${error.text})`);
+}
+export async function queryWithContext(query, logger, context, node, timeoutMs, contextData = {}) {
+    try {
+        return await query(node, timeoutMs);
+    }
+    catch (error) {
+        const normalized = toError(error);
+        logger.warn('query failed', {
+            context,
+            message: normalized.message,
+            tag: node.tag,
+            id: node.attrs.id,
+            type: node.attrs.type,
+            ...contextData
+        });
+        throw normalized;
+    }
+}

package/dist/esm/transport/node/xml.js

@@ -0,0 +1,39 @@
+import { bytesToBase64 } from '../../util/bytes.js';
+const XML_INDENT = '    ';
+function escapeXml(value) {
+    return value
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+function renderAttrs(attrs) {
+    const entries = Object.entries(attrs);
+    if (entries.length === 0) {
+        return '';
+    }
+    return entries.map(([key, value]) => ` ${key}='${escapeXml(value)}'`).join('');
+}
+function renderNode(node, depth) {
+    const indent = XML_INDENT.repeat(depth);
+    const attrs = renderAttrs(node.attrs);
+    const content = node.content;
+    if (content === undefined) {
+        return `${indent}<${node.tag}${attrs}/>`;
+    }
+    if (typeof content === 'string') {
+        return `${indent}<${node.tag}${attrs}>${escapeXml(content)}</${node.tag}>`;
+    }
+    if (content instanceof Uint8Array) {
+        return `${indent}<${node.tag}${attrs}>${bytesToBase64(content)}</${node.tag}>`;
+    }
+    if (content.length === 0) {
+        return `${indent}<${node.tag}${attrs}/>`;
+    }
+    const children = content.map((child) => renderNode(child, depth + 1)).join('\n');
+    return `${indent}<${node.tag}${attrs}>\n${children}\n${indent}</${node.tag}>`;
+}
+export function formatBinaryNodeAsXml(node) {
+    return renderNode(node, 0);
+}

package/dist/esm/transport/noise/WaClientPayload.js

@@ -0,0 +1,162 @@
+import { randomUUID } from 'node:crypto';
+import { md5Bytes } from '../../crypto/core/primitives.js';
+import { proto } from '../../proto.js';
+import { KEY_TYPE_CURVE25519 } from '../../signal/constants.js';
+import { DEFAULT_VERSION_BASE } from '../noise/constants.js';
+import { intToBytes, toBytesView } from '../../util/bytes.js';
+function parseVersion(versionBase) {
+    const [p = '2', s = '3000', t = '0'] = versionBase.split('.');
+    const primary = Number.parseInt(p, 10);
+    const secondary = Number.parseInt(s, 10);
+    const tertiary = Number.parseInt(t, 10);
+    if (!Number.isSafeInteger(primary) ||
+        !Number.isSafeInteger(secondary) ||
+        !Number.isSafeInteger(tertiary)) {
+        throw new Error(`invalid versionBase: ${versionBase}`);
+    }
+    return { primary, secondary, tertiary };
+}
+function resolveLocale() {
+    const locale = Intl.DateTimeFormat().resolvedOptions().locale || 'en-US';
+    const [language = 'en', country = 'US'] = locale.split('-');
+    return {
+        lg: language.toLowerCase(),
+        lc: country.toUpperCase()
+    };
+}
+function defaultWebSubPlatform() {
+    return proto.ClientPayload.WebInfo.WebSubPlatform.WEB_BROWSER;
+}
+function resolveDevicePropsPlatformType(deviceBrowser) {
+    const normalized = deviceBrowser?.trim().toLowerCase();
+    switch (normalized) {
+        case 'chrome':
+            return proto.DeviceProps.PlatformType.CHROME;
+        case 'firefox':
+            return proto.DeviceProps.PlatformType.FIREFOX;
+        case 'ie':
+            return proto.DeviceProps.PlatformType.IE;
+        case 'opera':
+            return proto.DeviceProps.PlatformType.OPERA;
+        case 'safari':
+            return proto.DeviceProps.PlatformType.SAFARI;
+        case 'edge':
+            return proto.DeviceProps.PlatformType.EDGE;
+        case 'electron':
+        case 'desktop':
+            return proto.DeviceProps.PlatformType.DESKTOP;
+        case 'ipad':
+            return proto.DeviceProps.PlatformType.IPAD;
+        case 'tablet':
+        case 'android tablet':
+            return proto.DeviceProps.PlatformType.ANDROID_TABLET;
+        case 'ohana':
+            return proto.DeviceProps.PlatformType.OHANA;
+        case 'aloha':
+            return proto.DeviceProps.PlatformType.ALOHA;
+        case 'catalina':
+            return proto.DeviceProps.PlatformType.CATALINA;
+        default:
+            return proto.DeviceProps.PlatformType.UNKNOWN;
+    }
+}
+function defaultUserAgent(versionBase, deviceOsDisplayName) {
+    const { primary, secondary, tertiary } = parseVersion(versionBase);
+    const locale = resolveLocale();
+    return {
+        platform: proto.ClientPayload.UserAgent.Platform.WEB,
+        releaseChannel: proto.ClientPayload.UserAgent.ReleaseChannel.RELEASE,
+        appVersion: {
+            primary,
+            secondary,
+            tertiary
+        },
+        mcc: '000',
+        mnc: '000',
+        osVersion: deviceOsDisplayName ?? process.platform,
+        manufacturer: '',
+        device: 'Desktop',
+        osBuildNumber: '0.1',
+        phoneId: randomUUID(),
+        localeLanguageIso6391: locale.lg,
+        localeCountryIso31661Alpha2: locale.lc
+    };
+}
+function defaultDeviceProps(versionBase, config) {
+    const { primary, secondary, tertiary } = parseVersion(versionBase);
+    return proto.DeviceProps.encode({
+        os: config.deviceOsDisplayName ?? process.platform,
+        version: {
+            primary,
+            secondary,
+            tertiary
+        },
+        platformType: resolveDevicePropsPlatformType(config.deviceBrowser),
+        requireFullSync: config.requireFullSync === true,
+        historySyncConfig: {
+            inlineInitialPayloadInE2EeMsg: true,
+            supportBotUserAgentChatHistory: true,
+            supportCagReactionsAndPolls: true,
+            supportRecentSyncChunkMessageCountTuning: true,
+            supportHostedGroupMsg: true,
+            supportBizHostedMsg: true,
+            supportFbidBotChatHistory: true,
+            supportMessageAssociation: true
+        }
+    }).finish();
+}
+function buildCommonPayload(config) {
+    const versionBase = config.versionBase ?? DEFAULT_VERSION_BASE;
+    const pull = config.pull ?? true;
+    return {
+        passive: config.passive === true,
+        pull,
+        connectType: proto.ClientPayload.ConnectType.WIFI_UNKNOWN,
+        connectReason: proto.ClientPayload.ConnectReason.USER_ACTIVATED,
+        userAgent: config.userAgent ?? defaultUserAgent(versionBase, config.deviceOsDisplayName),
+        webInfo: config.webInfo ??
+            {
+                webSubPlatform: defaultWebSubPlatform()
+            }
+    };
+}
+export function buildLoginPayload(config) {
+    if (!Number.isSafeInteger(config.username) || config.username <= 0) {
+        throw new Error('login payload requires a valid numeric username');
+    }
+    const common = buildCommonPayload(config);
+    return proto.ClientPayload.encode({
+        ...common,
+        username: config.username,
+        device: config.device ?? 0,
+        lidDbMigrated: config.lidDbMigrated === true
+    }).finish();
+}
+export function buildRegistrationPayload(config) {
+    const registrationId = config.registrationInfo.registrationId;
+    const signedPreKeyId = config.signedPreKey.keyId;
+    if (!Number.isSafeInteger(registrationId) || registrationId <= 0) {
+        throw new Error('registration payload requires a valid registrationId');
+    }
+    if (!Number.isSafeInteger(signedPreKeyId) || signedPreKeyId <= 0) {
+        throw new Error('registration payload requires a valid signedPreKeyId');
+    }
+    const versionBase = config.versionBase ?? DEFAULT_VERSION_BASE;
+    const common = buildCommonPayload(config);
+    const devicePairingData = {
+        buildHash: config.buildHash ? toBytesView(config.buildHash) : md5Bytes(versionBase),
+        deviceProps: config.deviceProps
+            ? toBytesView(config.deviceProps)
+            : defaultDeviceProps(versionBase, config),
+        eRegid: intToBytes(4, registrationId),
+        eKeytype: intToBytes(1, KEY_TYPE_CURVE25519),
+        eIdent: toBytesView(config.registrationInfo.identityKeyPair.pubKey),
+        eSkeyId: intToBytes(3, signedPreKeyId),
+        eSkeyVal: toBytesView(config.signedPreKey.keyPair.pubKey),
+        eSkeySig: toBytesView(config.signedPreKey.signature)
+    };
+    return proto.ClientPayload.encode({
+        ...common,
+        devicePairingData
+    }).finish();
+}

package/dist/esm/transport/noise/WaFrameCodec.js

@@ -0,0 +1,121 @@
+import { concatBytes, EMPTY_BYTES, toBytesView } from '../../util/bytes.js';
+const WA_MAX_FRAME_LENGTH = (1 << 24) - 1;
+function frameLength(header) {
+    return (header[0] << 16) | (header[1] << 8) | header[2];
+}
+export class WaFrameCodec {
+    constructor(introFrame, maxFrameLength = WA_MAX_FRAME_LENGTH) {
+        if (!Number.isSafeInteger(maxFrameLength) || maxFrameLength <= 0) {
+            throw new Error('maxFrameLength must be a positive safe integer');
+        }
+        if (maxFrameLength >= 1 << 24) {
+            throw new Error('maxFrameLength must be lower than protocol limit (16777216)');
+        }
+        this.introFrame = introFrame && introFrame.length > 0 ? toBytesView(introFrame) : null;
+        this.maxFrameLength = maxFrameLength;
+        this.introSent = false;
+        this.buffered = EMPTY_BYTES;
+    }
+    encodeFrame(frame) {
+        if (frame.length > this.maxFrameLength) {
+            throw new Error(`frame is too large: ${frame.length} bytes (max allowed: ${this.maxFrameLength})`);
+        }
+        if (!this.introSent && this.introFrame) {
+            this.introSent = true;
+            const out = new Uint8Array(this.introFrame.length + 3 + frame.length);
+            out.set(this.introFrame, 0);
+            const headerOffset = this.introFrame.length;
+            out[headerOffset] = (frame.length >> 16) & 0xff;
+            out[headerOffset + 1] = (frame.length >> 8) & 0xff;
+            out[headerOffset + 2] = frame.length & 0xff;
+            out.set(frame, headerOffset + 3);
+            return out;
+        }
+        this.introSent = true;
+        const out = new Uint8Array(3 + frame.length);
+        out[0] = (frame.length >> 16) & 0xff;
+        out[1] = (frame.length >> 8) & 0xff;
+        out[2] = frame.length & 0xff;
+        out.set(frame, 3);
+        return out;
+    }
+    pushWireChunk(chunk) {
+        if (chunk.length === 0) {
+            return [];
+        }
+        const frames = [];
+        let chunkOffset = 0;
+        if (this.buffered.length > 0) {
+            if (this.buffered.length < 3) {
+                const missingHeaderBytes = 3 - this.buffered.length;
+                if (chunk.length < missingHeaderBytes) {
+                    this.buffered = concatBytes([this.buffered, chunk]);
+                    return frames;
+                }
+                const header = new Uint8Array(3);
+                header.set(this.buffered, 0);
+                header.set(chunk.subarray(0, missingHeaderBytes), this.buffered.length);
+                const length = frameLength(header);
+                if (length > this.maxFrameLength) {
+                    throw new Error(`incoming frame is too large: ${length} bytes (max allowed: ${this.maxFrameLength})`);
+                }
+                const remainingAfterHeader = chunk.length - missingHeaderBytes;
+                if (remainingAfterHeader < length) {
+                    const nextBuffered = new Uint8Array(3 + remainingAfterHeader);
+                    nextBuffered.set(header, 0);
+                    nextBuffered.set(chunk.subarray(missingHeaderBytes), 3);
+                    this.buffered = nextBuffered;
+                    return frames;
+                }
+                frames.push(chunk.subarray(missingHeaderBytes, missingHeaderBytes + length));
+                chunkOffset = missingHeaderBytes + length;
+                this.buffered = EMPTY_BYTES;
+            }
+            else {
+                const header = this.buffered.subarray(0, 3);
+                const length = frameLength(header);
+                if (length > this.maxFrameLength) {
+                    throw new Error(`incoming frame is too large: ${length} bytes (max allowed: ${this.maxFrameLength})`);
+                }
+                const bufferedPayloadLength = this.buffered.length - 3;
+                const missingPayloadBytes = length - bufferedPayloadLength;
+                if (missingPayloadBytes > chunk.length) {
+                    this.buffered = concatBytes([this.buffered, chunk]);
+                    return frames;
+                }
+                if (bufferedPayloadLength === 0) {
+                    frames.push(chunk.subarray(0, missingPayloadBytes));
+                }
+                else {
+                    const frame = new Uint8Array(length);
+                    frame.set(this.buffered.subarray(3), 0);
+                    if (missingPayloadBytes > 0) {
+                        frame.set(chunk.subarray(0, missingPayloadBytes), bufferedPayloadLength);
+                    }
+                    frames.push(frame);
+                }
+                chunkOffset = missingPayloadBytes;
+                this.buffered = EMPTY_BYTES;
+            }
+        }
+        const remainingChunk = chunk.subarray(chunkOffset);
+        let offset = 0;
+        while (remainingChunk.length - offset >= 3) {
+            const header = remainingChunk.subarray(offset, offset + 3);
+            const length = frameLength(header);
+            if (length > this.maxFrameLength) {
+                throw new Error(`incoming frame is too large: ${length} bytes (max allowed: ${this.maxFrameLength})`);
+            }
+            if (remainingChunk.length - offset - 3 < length) {
+                break;
+            }
+            const start = offset + 3;
+            const end = start + length;
+            frames.push(remainingChunk.subarray(start, end));
+            offset = end;
+        }
+        this.buffered =
+            offset >= remainingChunk.length ? EMPTY_BYTES : remainingChunk.subarray(offset);
+        return frames;
+    }
+}

package/dist/esm/transport/noise/WaNoiseCert.js

@@ -0,0 +1,74 @@
+import { ed25519VerifyRaw, toSerializedPubKey } from '../../crypto/index.js';
+import { montgomeryToEdwardsPublic } from '../../crypto/curves/X25519.js';
+import { proto } from '../../proto.js';
+import { ROOT_CA_PUBLIC_KEY_HEX, ROOT_CA_SERIAL } from '../noise/constants.js';
+import { decodeProtoBytes } from '../../util/base64.js';
+import { hexToBytes, uint8Equal } from '../../util/bytes.js';
+import { toSafeNumber } from '../../util/primitives.js';
+async function verifySignalVariant(serializedPublicKey, message, signatureInput) {
+    const publicKey = toSerializedPubKey(serializedPublicKey);
+    if (signatureInput.length !== 64) {
+        return false;
+    }
+    const signature = new Uint8Array(signatureInput);
+    const lastByte = signature[63];
+    if ((lastByte & 0x60) !== 0) {
+        return false;
+    }
+    const signBit = lastByte & 0x80;
+    signature[63] = lastByte & 0x7f;
+    const edwardsPublicKey = montgomeryToEdwardsPublic(publicKey.subarray(1), signBit);
+    return ed25519VerifyRaw(edwardsPublicKey, signature, message);
+}
+function parseNoiseCertificate(certificate) {
+    if (!certificate) {
+        throw new Error('missing noise certificate');
+    }
+    const detailsBytes = decodeProtoBytes(certificate.details, 'certificate.details');
+    const signatureBytes = decodeProtoBytes(certificate.signature, 'certificate.signature');
+    if (signatureBytes.length !== 64) {
+        throw new Error('invalid certificate signature size');
+    }
+    const details = proto.CertChain.NoiseCertificate.Details.decode(detailsBytes);
+    const serial = toSafeNumber(details.serial, 'certificate.serial');
+    const issuerSerial = toSafeNumber(details.issuerSerial, 'certificate.issuerSerial');
+    const key = decodeProtoBytes(details.key, 'certificate.key');
+    return {
+        serial,
+        issuerSerial,
+        key,
+        details: detailsBytes,
+        signature: signatureBytes
+    };
+}
+function rootPublicKeySerialized() {
+    const raw = hexToBytes(ROOT_CA_PUBLIC_KEY_HEX);
+    return toSerializedPubKey(raw);
+}
+export async function verifyNoiseCertificateChain(certificateChain, serverStatic) {
+    const chain = proto.CertChain.decode(certificateChain);
+    if (!chain.leaf || !chain.intermediate) {
+        throw new Error('noise certificate chain is missing leaf/intermediate');
+    }
+    const intermediate = parseNoiseCertificate(chain.intermediate);
+    if (intermediate.issuerSerial !== ROOT_CA_SERIAL) {
+        throw new Error('intermediate certificate issuer mismatch');
+    }
+    const rootKey = rootPublicKeySerialized();
+    const validIntermediate = await verifySignalVariant(rootKey, intermediate.details, intermediate.signature);
+    if (!validIntermediate) {
+        throw new Error('intermediate certificate signature is invalid');
+    }
+    const leaf = parseNoiseCertificate(chain.leaf);
+    if (leaf.issuerSerial !== intermediate.serial) {
+        throw new Error('leaf certificate issuer mismatch');
+    }
+    const intermediatePublicSerialized = toSerializedPubKey(intermediate.key);
+    const validLeaf = await verifySignalVariant(intermediatePublicSerialized, leaf.details, leaf.signature);
+    if (!validLeaf) {
+        throw new Error('leaf certificate signature is invalid');
+    }
+    if (!uint8Equal(leaf.key, serverStatic)) {
+        throw new Error('leaf certificate key mismatch with server static key');
+    }
+}

package/dist/esm/transport/noise/WaNoiseHandshake.js

@@ -0,0 +1,57 @@
+import { aesGcmDecrypt, aesGcmEncrypt, buildNonce, hkdfSplit, importAesGcmKey, sha256 } from '../../crypto/index.js';
+import { WaNoiseSocket } from '../noise/WaNoiseSocket.js';
+import { concatBytes, EMPTY_BYTES } from '../../util/bytes.js';
+export class WaNoiseHandshake {
+    constructor() {
+        this.handshakeHash = EMPTY_BYTES;
+        this.chainingKey = EMPTY_BYTES;
+        this.cipherKey = null;
+        this.nonce = 0;
+    }
+    async start(protocolName, prologue) {
+        const hashInput = protocolName.length === 32 ? protocolName : await sha256(protocolName);
+        this.handshakeHash = hashInput;
+        this.chainingKey = hashInput;
+        this.cipherKey = await importAesGcmKey(this.handshakeHash, ['encrypt', 'decrypt']);
+        await this.authenticate(prologue);
+    }
+    async authenticate(data) {
+        this.handshakeHash = await sha256(concatBytes([this.handshakeHash, data]));
+    }
+    async mixIntoKey(keyMaterial) {
+        this.nonce = 0;
+        const [newChainingKey, nextCipherKey] = await hkdfSplit(keyMaterial, this.chainingKey, '');
+        this.chainingKey = newChainingKey;
+        this.cipherKey = await importAesGcmKey(nextCipherKey, ['encrypt', 'decrypt']);
+    }
+    async encrypt(plaintext) {
+        if (!this.cipherKey) {
+            throw new Error('noise handshake cipher key is not initialized');
+        }
+        const nonce = buildNonce(this.nonce++);
+        const ciphertext = await aesGcmEncrypt(this.cipherKey, nonce, plaintext, this.handshakeHash);
+        await this.authenticate(ciphertext);
+        return ciphertext;
+    }
+    async decrypt(ciphertext) {
+        if (!this.cipherKey) {
+            throw new Error('noise handshake cipher key is not initialized');
+        }
+        const nonce = buildNonce(this.nonce++);
+        const plaintext = await aesGcmDecrypt(this.cipherKey, nonce, ciphertext, this.handshakeHash);
+        await this.authenticate(ciphertext);
+        return plaintext;
+    }
+    async finish() {
+        const [writeKeyRaw, readKeyRaw] = await hkdfSplit(EMPTY_BYTES, this.chainingKey, '');
+        const [writeKey, readKey] = await Promise.all([
+            importAesGcmKey(writeKeyRaw, ['encrypt']),
+            importAesGcmKey(readKeyRaw, ['decrypt'])
+        ]);
+        this.handshakeHash = EMPTY_BYTES;
+        this.chainingKey = EMPTY_BYTES;
+        this.cipherKey = null;
+        this.nonce = 0;
+        return new WaNoiseSocket(writeKey, readKey);
+    }
+}