zapo-js 0.1.0

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

@@ -0,0 +1,322 @@
+import { X25519 } from '../../crypto/index.js';
+import { ConsoleLogger } from '../../infra/log/ConsoleLogger.js';
+import { BoundedTaskQueue } from '../../infra/perf/BoundedTaskQueue.js';
+import { proto } from '../../proto.js';
+import { WA_DEFAULTS } from '../../protocol/constants.js';
+import { NOISE_IK_NAME, NOISE_XX_FALLBACK_NAME, NOISE_XX_NAME, WA_PROTO_HEADER } from '../noise/constants.js';
+import { buildLoginPayload, buildRegistrationPayload } from '../noise/WaClientPayload.js';
+import { WaFrameCodec } from '../noise/WaFrameCodec.js';
+import { verifyNoiseCertificateChain } from '../noise/WaNoiseCert.js';
+import { WaNoiseHandshake } from '../noise/WaNoiseHandshake.js';
+import { concatBytes, toBytesView } from '../../util/bytes.js';
+import { toError } from '../../util/primitives.js';
+function resolvePayload(payload) {
+    if (payload instanceof Uint8Array) {
+        return Promise.resolve(payload);
+    }
+    return Promise.resolve(payload()).then((value) => toBytesView(value));
+}
+async function resolveHandshakePayload(config) {
+    if (config.isRegistered) {
+        if (config.loginPayload) {
+            return resolvePayload(config.loginPayload);
+        }
+        if (config.loginPayloadConfig) {
+            return buildLoginPayload(config.loginPayloadConfig);
+        }
+        throw new Error('noise login payload is missing');
+    }
+    if (config.registrationPayload) {
+        return resolvePayload(config.registrationPayload);
+    }
+    if (config.registrationPayloadConfig) {
+        return buildRegistrationPayload(config.registrationPayloadConfig);
+    }
+    throw new Error('noise registration payload is missing');
+}
+function buildRoutingInfoPrefix(routingInfo) {
+    const prefix = new Uint8Array(2 + 2 + 1 + 2 + routingInfo.length);
+    prefix[0] = 0x45; // E
+    prefix[1] = 0x44; // D
+    prefix[2] = 0x00;
+    prefix[3] = 0x01;
+    prefix[4] = (routingInfo.length >> 16) & 0xff;
+    prefix[5] = (routingInfo.length >> 8) & 0xff;
+    prefix[6] = routingInfo.length & 0xff;
+    prefix.set(routingInfo, 7);
+    return prefix;
+}
+export class WaNoiseSession {
+    constructor(sendWire, logger = new ConsoleLogger('info')) {
+        this.sendWire = sendWire;
+        this.logger = logger;
+        this.writeQueue = new BoundedTaskQueue(4096, 1);
+        this.readQueue = new BoundedTaskQueue(4096, 1);
+        this.frameCodec = null;
+        this.handshakeInbox = [];
+        this.handshakeWaiter = null;
+        this.handshakeRejecter = null;
+        this.pendingDecryptedFrames = [];
+        this.closedError = null;
+        this.noiseSocket = null;
+        this.serverStaticKey = null;
+        this.handshakeFrameTimeoutMs = WA_DEFAULTS.CONNECT_TIMEOUT_MS;
+    }
+    async start(config) {
+        this.reset();
+        this.logger.debug('noise session start', {
+            isRegistered: config.isRegistered,
+            hasServerStaticKey: !!config.serverStaticKey
+        });
+        const protocolHeader = config.protocolHeader
+            ? toBytesView(config.protocolHeader)
+            : WA_PROTO_HEADER;
+        const introFrame = config.routingInfo && config.routingInfo.length > 0
+            ? concatBytes([buildRoutingInfoPrefix(config.routingInfo), protocolHeader])
+            : protocolHeader;
+        this.frameCodec = new WaFrameCodec(introFrame);
+        const [ephemeralKeyPair, payload] = await Promise.all([
+            X25519.generateKeyPair(),
+            resolveHandshakePayload(config)
+        ]);
+        const verifyCertificates = config.verifyCertificateChain !== false;
+        if (config.serverStaticKey && config.serverStaticKey.length === 32) {
+            this.logger.info('noise session attempting resume handshake (IK)');
+            this.noiseSocket = await this.resumeHandshake(config.serverStaticKey, config.clientStaticKeyPair, ephemeralKeyPair, payload, protocolHeader, verifyCertificates);
+            await this.decodeBufferedPostHandshakeFrames();
+            this.logger.info('noise session established via resume/full fallback path');
+            return;
+        }
+        this.logger.info('noise session starting full handshake (XX)');
+        this.noiseSocket = await this.fullHandshake(config.clientStaticKeyPair, ephemeralKeyPair, payload, protocolHeader, verifyCertificates);
+        await this.decodeBufferedPostHandshakeFrames();
+        this.logger.info('noise session established via full handshake');
+    }
+    async encryptFrame(frame) {
+        if (!this.noiseSocket || !this.frameCodec) {
+            throw new Error('noise session is not established');
+        }
+        const encrypted = await this.writeQueue.enqueue(() => this.noiseSocket.encrypt(frame));
+        return this.frameCodec.encodeFrame(encrypted);
+    }
+    async pushWireChunk(chunk) {
+        const codec = this.frameCodec;
+        if (!codec) {
+            return [];
+        }
+        const out = [];
+        if (this.pendingDecryptedFrames.length > 0) {
+            out.push(...this.pendingDecryptedFrames);
+            this.pendingDecryptedFrames = [];
+        }
+        const frames = codec.pushWireChunk(chunk);
+        if (!this.noiseSocket) {
+            for (const frame of frames) {
+                const waiter = this.handshakeWaiter;
+                const rejecter = this.handshakeRejecter;
+                if (waiter && rejecter) {
+                    this.handshakeWaiter = null;
+                    this.handshakeRejecter = null;
+                    waiter(frame);
+                    continue;
+                }
+                this.handshakeInbox.push(frame);
+            }
+            return out;
+        }
+        for (const frame of frames) {
+            const decrypted = await this.readQueue.enqueue(() => this.noiseSocket.decrypt(frame));
+            out.push(decrypted);
+        }
+        return out;
+    }
+    onSocketClosed(error) {
+        const closeError = error ?? new Error('noise session socket closed');
+        this.logger.debug('noise session socket closed', { message: closeError.message });
+        this.closedError = closeError;
+        const rejecter = this.handshakeRejecter;
+        if (rejecter) {
+            this.handshakeRejecter = null;
+            this.handshakeWaiter = null;
+            rejecter(closeError);
+        }
+    }
+    reset() {
+        this.logger.trace('noise session reset');
+        this.frameCodec = null;
+        this.handshakeInbox = [];
+        this.handshakeWaiter = null;
+        this.handshakeRejecter = null;
+        this.pendingDecryptedFrames = [];
+        this.closedError = null;
+        this.noiseSocket = null;
+        this.serverStaticKey = null;
+    }
+    getServerStaticKey() {
+        if (!this.serverStaticKey) {
+            return null;
+        }
+        return this.serverStaticKey;
+    }
+    async fullHandshake(clientStaticKeyPair, ephemeralKeyPair, payload, protocolHeader, verifyCertificates) {
+        this.logger.trace('noise full handshake: send client hello');
+        const handshake = new WaNoiseHandshake();
+        await handshake.start(NOISE_XX_NAME, protocolHeader);
+        await handshake.authenticate(ephemeralKeyPair.pubKey);
+        const clientHello = proto.HandshakeMessage.encode({
+            clientHello: {
+                ephemeral: ephemeralKeyPair.pubKey
+            }
+        }).finish();
+        const serverHello = await this.sendAndReceiveHandshakeFrame(clientHello);
+        return this.continueFullHandshake(handshake, serverHello, clientStaticKeyPair, ephemeralKeyPair, payload, verifyCertificates);
+    }
+    async resumeHandshake(serverStaticKey, clientStaticKeyPair, ephemeralKeyPair, payload, protocolHeader, verifyCertificates) {
+        const resumeResult = await this.tryResumeHandshakeWithIk(serverStaticKey, clientStaticKeyPair, ephemeralKeyPair, payload, protocolHeader);
+        if (resumeResult.socket) {
+            return resumeResult.socket;
+        }
+        this.logger.info('noise resume handshake fallback to XX');
+        return this.resumeHandshakeWithFallback(clientStaticKeyPair, ephemeralKeyPair, payload, protocolHeader, resumeResult.serverHelloFrame, verifyCertificates);
+    }
+    async tryResumeHandshakeWithIk(serverStaticKey, clientStaticKeyPair, ephemeralKeyPair, payload, protocolHeader) {
+        this.logger.trace('noise resume handshake: send IK client hello');
+        const handshake = new WaNoiseHandshake();
+        await handshake.start(NOISE_IK_NAME, protocolHeader);
+        await handshake.authenticate(serverStaticKey);
+        await handshake.authenticate(ephemeralKeyPair.pubKey);
+        const agreement1 = await X25519.scalarMult(ephemeralKeyPair.privKey, serverStaticKey);
+        await handshake.mixIntoKey(agreement1);
+        const encryptedClientStatic = await handshake.encrypt(clientStaticKeyPair.pubKey);
+        const agreement2 = await X25519.scalarMult(clientStaticKeyPair.privKey, serverStaticKey);
+        await handshake.mixIntoKey(agreement2);
+        const encryptedPayload = await handshake.encrypt(payload);
+        const clientHello = proto.HandshakeMessage.encode({
+            clientHello: {
+                ephemeral: ephemeralKeyPair.pubKey,
+                payload: encryptedPayload,
+                static: encryptedClientStatic
+            }
+        }).finish();
+        const serverHelloFrame = await this.sendAndReceiveHandshakeFrame(clientHello);
+        const parsed = proto.HandshakeMessage.decode(serverHelloFrame);
+        const serverHello = parsed.serverHello;
+        if (!serverHello) {
+            throw new Error('noise resume handshake missing serverHello');
+        }
+        if (serverHello.static) {
+            return { socket: null, serverHelloFrame };
+        }
+        if (!serverHello.ephemeral) {
+            throw new Error('noise resume handshake missing server ephemeral');
+        }
+        if (!serverHello.payload) {
+            throw new Error('noise resume handshake missing certificate payload');
+        }
+        const serverEphemeral = toBytesView(serverHello.ephemeral);
+        await handshake.authenticate(serverEphemeral);
+        await handshake.mixIntoKey(await X25519.scalarMult(ephemeralKeyPair.privKey, serverEphemeral));
+        await handshake.mixIntoKey(await X25519.scalarMult(clientStaticKeyPair.privKey, serverEphemeral));
+        await handshake.decrypt(toBytesView(serverHello.payload));
+        this.serverStaticKey = serverStaticKey;
+        this.logger.info('noise resume handshake successful without fallback');
+        return { socket: await handshake.finish(), serverHelloFrame: null };
+    }
+    async resumeHandshakeWithFallback(clientStaticKeyPair, ephemeralKeyPair, payload, protocolHeader, serverHelloFrame, verifyCertificates) {
+        const fallback = new WaNoiseHandshake();
+        await fallback.start(NOISE_XX_FALLBACK_NAME, protocolHeader);
+        await fallback.authenticate(ephemeralKeyPair.pubKey);
+        return this.continueFullHandshake(fallback, serverHelloFrame, clientStaticKeyPair, ephemeralKeyPair, payload, verifyCertificates);
+    }
+    async continueFullHandshake(handshake, serverHelloFrame, clientStaticKeyPair, ephemeralKeyPair, payload, verifyCertificates) {
+        this.logger.trace('noise continue full handshake');
+        const parsed = proto.HandshakeMessage.decode(serverHelloFrame);
+        const serverHello = parsed.serverHello;
+        if (!serverHello?.ephemeral || !serverHello.static || !serverHello.payload) {
+            throw new Error('noise full handshake missing server hello fields');
+        }
+        const serverEphemeral = toBytesView(serverHello.ephemeral);
+        await handshake.authenticate(serverEphemeral);
+        await handshake.mixIntoKey(await X25519.scalarMult(ephemeralKeyPair.privKey, serverEphemeral));
+        const serverStatic = await handshake.decrypt(toBytesView(serverHello.static));
+        await handshake.mixIntoKey(await X25519.scalarMult(ephemeralKeyPair.privKey, serverStatic));
+        const certificate = await handshake.decrypt(toBytesView(serverHello.payload));
+        if (verifyCertificates) {
+            await verifyNoiseCertificateChain(certificate, serverStatic);
+            this.logger.trace('noise certificate chain verified');
+        }
+        this.serverStaticKey = serverStatic;
+        const encryptedClientStatic = await handshake.encrypt(clientStaticKeyPair.pubKey);
+        await handshake.mixIntoKey(await X25519.scalarMult(clientStaticKeyPair.privKey, serverEphemeral));
+        const encryptedPayload = await handshake.encrypt(payload);
+        const clientFinish = proto.HandshakeMessage.encode({
+            clientFinish: {
+                static: encryptedClientStatic,
+                payload: encryptedPayload
+            }
+        }).finish();
+        await this.sendHandshakeFrame(clientFinish);
+        this.logger.trace('noise full handshake client finish sent');
+        return handshake.finish();
+    }
+    async sendHandshakeFrame(frame) {
+        const codec = this.frameCodec;
+        if (!codec) {
+            throw new Error('noise frame codec is not initialized');
+        }
+        this.logger.trace('noise send handshake frame', { byteLength: frame.byteLength });
+        await this.sendWire(codec.encodeFrame(frame));
+    }
+    async sendAndReceiveHandshakeFrame(frame) {
+        await this.sendHandshakeFrame(frame);
+        return this.waitHandshakeFrame();
+    }
+    async waitHandshakeFrame() {
+        if (this.closedError) {
+            throw this.closedError;
+        }
+        const queued = this.handshakeInbox.shift();
+        if (queued) {
+            this.logger.trace('noise handshake frame consumed from queue');
+            return queued;
+        }
+        this.logger.trace('noise waiting handshake frame');
+        return new Promise((resolve, reject) => {
+            if (this.closedError) {
+                reject(this.closedError);
+                return;
+            }
+            const timeout = setTimeout(() => {
+                if (this.handshakeWaiter === resolve) {
+                    this.handshakeWaiter = null;
+                    this.handshakeRejecter = null;
+                }
+                reject(new Error(`noise handshake frame timeout after ${this.handshakeFrameTimeoutMs}ms`));
+            }, this.handshakeFrameTimeoutMs);
+            timeout.unref?.();
+            this.handshakeWaiter = (frame) => {
+                clearTimeout(timeout);
+                resolve(frame);
+            };
+            this.handshakeRejecter = (error) => {
+                clearTimeout(timeout);
+                reject(error);
+            };
+        }).catch((error) => {
+            throw toError(error);
+        });
+    }
+    async decodeBufferedPostHandshakeFrames() {
+        if (!this.noiseSocket || this.handshakeInbox.length === 0) {
+            return;
+        }
+        this.logger.debug('decoding buffered post-handshake frames', {
+            count: this.handshakeInbox.length
+        });
+        const buffered = this.handshakeInbox.splice(0, this.handshakeInbox.length);
+        for (const frame of buffered) {
+            const decrypted = await this.readQueue.enqueue(() => this.noiseSocket.decrypt(frame));
+            this.pendingDecryptedFrames.push(decrypted);
+        }
+    }
+}

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

@@ -0,0 +1,17 @@
+import { aesGcmDecrypt, aesGcmEncrypt, buildNonce } from '../../crypto/index.js';
+export class WaNoiseSocket {
+    constructor(encryptKey, decryptKey) {
+        this.encryptKey = encryptKey;
+        this.decryptKey = decryptKey;
+        this.writeCounter = 0;
+        this.readCounter = 0;
+    }
+    async encrypt(frame, additionalData) {
+        const nonce = buildNonce(this.writeCounter++);
+        return aesGcmEncrypt(this.encryptKey, nonce, frame, additionalData);
+    }
+    async decrypt(frame, additionalData) {
+        const nonce = buildNonce(this.readCounter++);
+        return aesGcmDecrypt(this.decryptKey, nonce, frame, additionalData);
+    }
+}

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

@@ -0,0 +1,8 @@
+import { TEXT_ENCODER } from '../../util/bytes.js';
+export const DEFAULT_VERSION_BASE = '2.3000.1034748654';
+export const WA_PROTO_HEADER = new Uint8Array([87, 65, 6, 3]);
+export const NOISE_XX_NAME = TEXT_ENCODER.encode('Noise_XX_25519_AESGCM_SHA256\0\0\0\0');
+export const NOISE_IK_NAME = TEXT_ENCODER.encode('Noise_IK_25519_AESGCM_SHA256\0\0\0\0');
+export const NOISE_XX_FALLBACK_NAME = TEXT_ENCODER.encode('Noise_XXfallback_25519_AESGCM_SHA256');
+export const ROOT_CA_SERIAL = 0;
+export const ROOT_CA_PUBLIC_KEY_HEX = '142375574d0a587166aae71ebe516437c4a28b73e3695c6ce1f7f9545da8ee6b';

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

@@ -0,0 +1 @@
+export {};

package/dist/esm/transport/stream/parse.js

@@ -0,0 +1,91 @@
+import { WA_STREAM_SIGNALING } from '../../protocol/constants.js';
+import { findNodeChild, hasNodeChild } from '../node/helpers.js';
+import { base64ToBytes } from '../../util/base64.js';
+function parseStrictUnsignedInt(value) {
+    if (!/^\d+$/.test(value)) {
+        return undefined;
+    }
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed)) {
+        return undefined;
+    }
+    return parsed;
+}
+export function parseStreamControlNode(node) {
+    if (node.tag === WA_STREAM_SIGNALING.XML_STREAM_END_TAG) {
+        return {
+            kind: 'xmlstreamend'
+        };
+    }
+    if (node.tag !== WA_STREAM_SIGNALING.STREAM_ERROR_TAG) {
+        return null;
+    }
+    const conflictNode = findNodeChild(node, WA_STREAM_SIGNALING.CONFLICT_TAG);
+    if (conflictNode) {
+        if (conflictNode.attrs.type === WA_STREAM_SIGNALING.REPLACED_TYPE) {
+            return {
+                kind: 'stream_error_replaced'
+            };
+        }
+        return {
+            kind: 'stream_error_device_removed'
+        };
+    }
+    const codeRaw = node.attrs.code;
+    if (codeRaw) {
+        const code = parseStrictUnsignedInt(codeRaw);
+        if (code !== undefined) {
+            return {
+                kind: 'stream_error_code',
+                code
+            };
+        }
+    }
+    const ackNode = findNodeChild(node, WA_STREAM_SIGNALING.ACK_TAG);
+    if (ackNode) {
+        return {
+            kind: 'stream_error_ack',
+            id: ackNode.attrs.id
+        };
+    }
+    if (hasNodeChild(node, WA_STREAM_SIGNALING.XML_NOT_WELL_FORMED_TAG)) {
+        return {
+            kind: 'stream_error_xml_not_well_formed'
+        };
+    }
+    return {
+        kind: 'stream_error_other'
+    };
+}
+export function parseOptionalInt(value) {
+    if (!value) {
+        return undefined;
+    }
+    return parseStrictUnsignedInt(value);
+}
+export function parseCompanionEncStatic(value, onError) {
+    if (!value) {
+        return undefined;
+    }
+    try {
+        return base64ToBytes(value, 'success.companion_enc_static');
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            onError?.(error);
+        }
+        return undefined;
+    }
+}
+export function parseSuccessPersistAttributes(node, onCompanionParseError) {
+    return {
+        meLid: node.attrs.lid,
+        meDisplayName: node.attrs.display_name,
+        companionEncStatic: parseCompanionEncStatic(node.attrs.companion_enc_static, onCompanionParseError),
+        lastSuccessTs: parseOptionalInt(node.attrs.t),
+        propsVersion: parseOptionalInt(node.attrs.props),
+        abPropsVersion: parseOptionalInt(node.attrs.abprops),
+        connectionLocation: node.attrs.location,
+        accountCreationTs: parseOptionalInt(node.attrs.creation)
+    };
+}

package/dist/esm/transport/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/util/async.js

@@ -0,0 +1,5 @@
+export function delay(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}

package/dist/esm/util/base64.js

@@ -0,0 +1,18 @@
+import { base64ToBytes as decodeBase64, bytesToBase64, bytesToBase64UrlSafe } from './bytes.js';
+export { bytesToBase64, bytesToBase64UrlSafe };
+export function base64ToBytes(value, field, requireNonEmpty = true) {
+    const out = decodeBase64(value);
+    if (requireNonEmpty && out.length === 0) {
+        throw new Error(`invalid base64 payload for ${field}`);
+    }
+    return out;
+}
+export function decodeProtoBytes(value, field) {
+    if (value === null || value === undefined) {
+        throw new Error(`missing protobuf bytes field ${field}`);
+    }
+    if (value instanceof Uint8Array) {
+        return value;
+    }
+    return decodeBase64(value);
+}