zapo-js 0.1.0

package/dist/retry/parse.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRetryReceiptRequest = parseRetryReceiptRequest;
+const constants_1 = require("../protocol/constants");
+const constants_2 = require("../signal/api/constants");
+const helpers_1 = require("../transport/node/helpers");
+const parse_1 = require("../transport/stream/parse");
+function parseFixedLengthBytes(value, byteLength, field) {
+    const out = (0, helpers_1.decodeNodeContentBase64OrBytes)(value, field);
+    if (out.byteLength !== byteLength) {
+        throw new Error(`${field} must be ${byteLength} bytes`);
+    }
+    return out;
+}
+function parseBigEndianUint(bytes, field) {
+    if (bytes.byteLength === 0 || bytes.byteLength > 4) {
+        throw new Error(`${field} has invalid byte length`);
+    }
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    if (bytes.byteLength === 1) {
+        return view.getUint8(0);
+    }
+    if (bytes.byteLength === 2) {
+        return view.getUint16(0);
+    }
+    return bytes.byteLength === 3 ? (view.getUint16(0) << 8) | view.getUint8(2) : view.getUint32(0);
+}
+function parseRetryType(value) {
+    if (value === 'retry' || value === 'enc_rekey_retry') {
+        return value;
+    }
+    return null;
+}
+function parseRetryCount(value) {
+    const parsed = (0, parse_1.parseOptionalInt)(value);
+    if (parsed === undefined) {
+        return 0;
+    }
+    if (parsed < 0) {
+        throw new Error('retry count must be >= 0');
+    }
+    return parsed;
+}
+function parseRetryReason(value) {
+    const parsed = (0, parse_1.parseOptionalInt)(value);
+    if (parsed === undefined) {
+        return undefined;
+    }
+    if (parsed < 0) {
+        throw new Error('retry reason must be >= 0');
+    }
+    return parsed;
+}
+function parseRetryKeyBundle(node) {
+    if (!node) {
+        return undefined;
+    }
+    const identityNode = (0, helpers_1.findNodeChild)(node, constants_1.WA_NODE_TAGS.IDENTITY);
+    const signedKeyNode = (0, helpers_1.findNodeChild)(node, constants_1.WA_NODE_TAGS.SKEY);
+    if (!identityNode || !signedKeyNode) {
+        throw new Error('retry keys section missing identity or skey');
+    }
+    const signedKeyIdNode = (0, helpers_1.findNodeChild)(signedKeyNode, constants_1.WA_NODE_TAGS.ID);
+    const signedKeyValueNode = (0, helpers_1.findNodeChild)(signedKeyNode, constants_1.WA_NODE_TAGS.VALUE);
+    const signedKeySignatureNode = (0, helpers_1.findNodeChild)(signedKeyNode, constants_1.WA_NODE_TAGS.SIGNATURE);
+    if (!signedKeyIdNode || !signedKeyValueNode || !signedKeySignatureNode) {
+        throw new Error('retry keys section has incomplete skey');
+    }
+    const keyNode = (0, helpers_1.findNodeChild)(node, constants_1.WA_NODE_TAGS.KEY);
+    const keyIdNode = keyNode ? (0, helpers_1.findNodeChild)(keyNode, constants_1.WA_NODE_TAGS.ID) : undefined;
+    const keyValueNode = keyNode ? (0, helpers_1.findNodeChild)(keyNode, constants_1.WA_NODE_TAGS.VALUE) : undefined;
+    if (keyNode && (!keyIdNode || !keyValueNode)) {
+        throw new Error('retry keys section has incomplete key');
+    }
+    const deviceIdentityNode = (0, helpers_1.findNodeChild)(node, constants_1.WA_NODE_TAGS.DEVICE_IDENTITY);
+    return {
+        identity: parseFixedLengthBytes(identityNode.content, constants_2.SIGNAL_KEY_DATA_LENGTH, 'retry.keys.identity'),
+        deviceIdentity: deviceIdentityNode
+            ? (0, helpers_1.decodeNodeContentBase64OrBytes)(deviceIdentityNode.content, 'retry.keys.device-identity')
+            : undefined,
+        key: keyIdNode && keyValueNode
+            ? {
+                id: parseBigEndianUint(parseFixedLengthBytes(keyIdNode.content, constants_2.SIGNAL_KEY_ID_LENGTH, 'retry.keys.key.id'), 'retry.keys.key.id'),
+                publicKey: parseFixedLengthBytes(keyValueNode.content, constants_2.SIGNAL_KEY_DATA_LENGTH, 'retry.keys.key.value')
+            }
+            : undefined,
+        skey: {
+            id: parseBigEndianUint(parseFixedLengthBytes(signedKeyIdNode.content, constants_2.SIGNAL_KEY_ID_LENGTH, 'retry.keys.skey.id'), 'retry.keys.skey.id'),
+            publicKey: parseFixedLengthBytes(signedKeyValueNode.content, constants_2.SIGNAL_KEY_DATA_LENGTH, 'retry.keys.skey.value'),
+            signature: parseFixedLengthBytes(signedKeySignatureNode.content, constants_2.SIGNAL_SIGNATURE_LENGTH, 'retry.keys.skey.signature')
+        }
+    };
+}
+function parseRetryReceiptRequest(node) {
+    if (node.tag !== constants_1.WA_MESSAGE_TAGS.RECEIPT) {
+        return null;
+    }
+    const receiptType = parseRetryType(node.attrs.type);
+    if (!receiptType) {
+        return null;
+    }
+    const stanzaId = node.attrs.id;
+    const from = node.attrs.from;
+    if (!stanzaId || !from) {
+        throw new Error('retry receipt is missing id/from attrs');
+    }
+    const retryNode = (0, helpers_1.findNodeChild)(node, 'retry');
+    if (!retryNode) {
+        throw new Error('retry receipt is missing retry child');
+    }
+    const registrationNode = (0, helpers_1.findNodeChild)(node, constants_1.WA_NODE_TAGS.REGISTRATION);
+    if (!registrationNode) {
+        throw new Error('retry receipt is missing registration child');
+    }
+    const originalMsgId = retryNode.attrs.id;
+    if (!originalMsgId) {
+        throw new Error('retry receipt is missing retry.id');
+    }
+    const registration = parseFixedLengthBytes(registrationNode.content, constants_2.SIGNAL_REGISTRATION_ID_LENGTH, 'retry.registration');
+    return {
+        type: receiptType,
+        stanzaId,
+        from,
+        participant: node.attrs.participant,
+        recipient: node.attrs.recipient,
+        originalMsgId,
+        retryCount: parseRetryCount(retryNode.attrs.count),
+        retryReason: parseRetryReason(retryNode.attrs.error ?? node.attrs.error),
+        t: retryNode.attrs.t ?? node.attrs.t,
+        regId: parseBigEndianUint(registration, 'retry.registration'),
+        keyBundle: parseRetryKeyBundle((0, helpers_1.findNodeChild)(node, 'keys'))
+    };
+}

package/dist/retry/reason.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapRetryReasonFromError = mapRetryReasonFromError;
+const constants_1 = require("./constants");
+const primitives_1 = require("../util/primitives");
+const RETRY_REASON_MATCHERS = [
+    {
+        matches: ['no session', 'session not found'],
+        code: constants_1.RETRY_REASON.SignalErrorNoSession
+    },
+    { matches: ['invalid key id'], code: constants_1.RETRY_REASON.SignalErrorInvalidKeyId },
+    { matches: ['invalid key'], code: constants_1.RETRY_REASON.SignalErrorInvalidKey },
+    {
+        matches: [
+            'invalid signal message',
+            'invalid prekey signal message',
+            'invalid sender key message'
+        ],
+        code: constants_1.RETRY_REASON.SignalErrorInvalidMessage
+    },
+    { matches: ['invalid signature'], code: constants_1.RETRY_REASON.SignalErrorInvalidSignature },
+    {
+        matches: ['too many messages in future', 'future message'],
+        code: constants_1.RETRY_REASON.SignalErrorFutureMessage
+    },
+    { matches: ['invalid mac'], code: constants_1.RETRY_REASON.SignalErrorBadMac },
+    { matches: ['invalid session'], code: constants_1.RETRY_REASON.SignalErrorInvalidSession },
+    { matches: ['invalid message key'], code: constants_1.RETRY_REASON.SignalErrorInvalidMsgKey },
+    {
+        matches: [['broadcast', 'ephemeral']],
+        code: constants_1.RETRY_REASON.BadBroadcastEphemeralSetting
+    },
+    {
+        matches: ['unknown companion', 'unknown device'],
+        code: constants_1.RETRY_REASON.UnknownCompanionNoPrekey
+    },
+    { matches: ['adv'], code: constants_1.RETRY_REASON.AdvFailure },
+    {
+        matches: [['status', 'revoke', 'delay']],
+        code: constants_1.RETRY_REASON.StatusRevokeDelay
+    }
+];
+function mapRetryReasonFromError(error) {
+    const message = (0, primitives_1.toError)(error).message.toLowerCase();
+    for (const matcher of RETRY_REASON_MATCHERS) {
+        if (matcher.matches.some((candidate) => Array.isArray(candidate)
+            ? candidate.every((part) => message.includes(part))
+            : message.includes(candidate))) {
+            return matcher.code;
+        }
+    }
+    return constants_1.RETRY_REASON.UnknownError;
+}

package/dist/retry/replay.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaRetryReplayService = void 0;
+const device_sent_1 = require("../message/device-sent");
+const padding_1 = require("../message/padding");
+const _proto_1 = require("../proto.js");
+const jid_1 = require("../protocol/jid");
+const outbound_1 = require("./outbound");
+const binary_1 = require("../transport/binary");
+const message_1 = require("../transport/node/builders/message");
+const helpers_1 = require("../transport/node/helpers");
+const primitives_1 = require("../util/primitives");
+class WaRetryReplayService {
+    constructor(options) {
+        this.options = options;
+    }
+    async resendOutboundMessage(outbound, requesterJid, retryCount) {
+        const payload = (0, outbound_1.decodeRetryReplayPayload)(outbound.replayPayload);
+        if (payload.mode === 'plaintext') {
+            return this.resendPlaintextPayload(outbound, payload, requesterJid, retryCount);
+        }
+        if (payload.mode === 'encrypted') {
+            return this.resendEncryptedPayload(outbound, payload, requesterJid, retryCount);
+        }
+        return this.resendOpaquePayload(outbound, payload, requesterJid);
+    }
+    async resendPlaintextPayload(outbound, payload, requesterJid, retryCount) {
+        if ((0, jid_1.isGroupOrBroadcastJid)(payload.to)) {
+            return this.resendGroupPlaintextPayload(outbound, payload, requesterJid);
+        }
+        let payloadUserJid;
+        let requesterUserJid;
+        try {
+            payloadUserJid = (0, jid_1.toUserJid)(payload.to);
+            requesterUserJid = (0, jid_1.toUserJid)(requesterJid);
+        }
+        catch {
+            return 'ineligible';
+        }
+        if (payloadUserJid !== requesterUserJid) {
+            return 'ineligible';
+        }
+        const encrypted = await this.signalProtocol.encryptMessage((0, jid_1.parseSignalAddressFromJid)(requesterJid), payload.plaintext);
+        await this.messageClient.sendEncrypted({
+            to: requesterJid,
+            encType: encrypted.type,
+            ciphertext: encrypted.ciphertext,
+            encCount: retryCount,
+            id: outbound.messageId,
+            type: payload.type
+        });
+        return 'resent';
+    }
+    async resendGroupPlaintextPayload(outbound, payload, requesterJid) {
+        const plaintext = (await this.maybeWrapGroupRetryPlaintextForSelfDevice(payload, requesterJid)) ??
+            payload.plaintext;
+        const encrypted = await this.signalProtocol.encryptMessage((0, jid_1.parseSignalAddressFromJid)(requesterJid), plaintext);
+        let deviceIdentity;
+        if (encrypted.type === 'pkmsg') {
+            const signedIdentity = this.getCurrentSignedIdentity();
+            if (!signedIdentity) {
+                this.logger.warn('retry request rejected: missing signed identity for pkmsg group retry');
+                return 'ineligible';
+            }
+            deviceIdentity = _proto_1.proto.ADVSignedDeviceIdentity.encode(signedIdentity).finish();
+        }
+        const retryNode = (0, message_1.buildGroupRetryMessageNode)({
+            to: payload.to,
+            type: payload.type,
+            id: outbound.messageId,
+            requesterJid,
+            addressingMode: (0, jid_1.splitJid)(requesterJid).server === 'lid' ? 'lid' : 'pn',
+            encType: encrypted.type,
+            ciphertext: encrypted.ciphertext,
+            deviceIdentity
+        });
+        await this.messageClient.sendMessageNode(retryNode);
+        return 'resent';
+    }
+    async resendEncryptedPayload(outbound, payload, requesterJid, retryCount) {
+        if (payload.encType === 'skmsg') {
+            return 'ineligible';
+        }
+        if ((0, jid_1.normalizeDeviceJid)(payload.to) !== (0, jid_1.normalizeDeviceJid)(requesterJid)) {
+            return 'ineligible';
+        }
+        await this.messageClient.sendEncrypted({
+            to: requesterJid,
+            encType: payload.encType,
+            ciphertext: payload.ciphertext,
+            encCount: retryCount,
+            id: outbound.messageId,
+            type: payload.type,
+            participant: payload.participant
+        });
+        return 'resent';
+    }
+    async resendOpaquePayload(outbound, payload, requesterJid) {
+        const decoded = (0, binary_1.decodeBinaryNode)(payload.node);
+        const replayNode = decoded.attrs.id === outbound.messageId
+            ? decoded
+            : {
+                ...decoded,
+                attrs: {
+                    ...decoded.attrs,
+                    id: outbound.messageId
+                }
+            };
+        if (!this.isOpaqueReplayCompatible(replayNode, requesterJid)) {
+            return 'ineligible';
+        }
+        await this.messageClient.sendMessageNode(replayNode);
+        return 'resent';
+    }
+    async maybeWrapGroupRetryPlaintextForSelfDevice(payload, requesterJid) {
+        if (!this.isRequesterCurrentAccount(requesterJid)) {
+            return null;
+        }
+        try {
+            const messageBytes = (0, padding_1.unpadPkcs7)(payload.plaintext);
+            const message = _proto_1.proto.Message.decode(messageBytes);
+            const wrapped = (0, device_sent_1.wrapDeviceSentMessage)(message, payload.to);
+            return (0, padding_1.writeRandomPadMax16)(_proto_1.proto.Message.encode(wrapped).finish());
+        }
+        catch (error) {
+            this.logger.warn('retry request failed to wrap deviceSent payload for self requester', {
+                requester: requesterJid,
+                to: payload.to,
+                message: (0, primitives_1.toError)(error).message
+            });
+            return null;
+        }
+    }
+    isRequesterCurrentAccount(requesterJid) {
+        const requesterUser = (0, jid_1.toUserJid)(requesterJid);
+        const meJid = this.options.getCurrentMeJid();
+        if (meJid && (0, jid_1.toUserJid)(meJid) === requesterUser) {
+            return true;
+        }
+        const meLid = this.options.getCurrentMeLid();
+        if (meLid && (0, jid_1.toUserJid)(meLid) === requesterUser) {
+            return true;
+        }
+        return false;
+    }
+    get logger() {
+        return this.options.logger;
+    }
+    get messageClient() {
+        return this.options.messageClient;
+    }
+    get signalProtocol() {
+        return this.options.signalProtocol;
+    }
+    getCurrentSignedIdentity() {
+        return this.options.getCurrentSignedIdentity();
+    }
+    isOpaqueReplayCompatible(node, requesterJid) {
+        const requester = (0, jid_1.normalizeDeviceJid)(requesterJid);
+        const participantsNode = (0, helpers_1.findNodeChild)(node, 'participants');
+        if (participantsNode) {
+            const toNodes = (0, helpers_1.getNodeChildrenByTag)(participantsNode, 'to');
+            if (toNodes.length !== 1) {
+                return false;
+            }
+            const participantJid = toNodes[0].attrs.jid;
+            if (!participantJid) {
+                return false;
+            }
+            return (0, jid_1.normalizeDeviceJid)(participantJid) === requester;
+        }
+        if (node.attrs.participant) {
+            return (0, jid_1.normalizeDeviceJid)(node.attrs.participant) === requester;
+        }
+        if (node.attrs.to) {
+            return (0, jid_1.normalizeDeviceJid)(node.attrs.to) === requester;
+        }
+        return false;
+    }
+}
+exports.WaRetryReplayService = WaRetryReplayService;

package/dist/retry/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/signal/api/SignalDeviceSyncApi.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignalDeviceSyncApi = void 0;
+const node_crypto_1 = require("node:crypto");
+const constants_1 = require("../../protocol/constants");
+const jid_1 = require("../../protocol/jid");
+const helpers_1 = require("../../transport/node/helpers");
+const query_1 = require("../../transport/node/query");
+class SignalDeviceSyncApi {
+    constructor(options) {
+        this.logger = options.logger;
+        this.query = options.query;
+        this.deviceListStore = options.deviceListStore;
+        this.defaultTimeoutMs =
+            options.defaultTimeoutMs ?? constants_1.WA_DEFAULTS.SIGNAL_FETCH_KEY_BUNDLES_TIMEOUT_MS;
+        this.hostDomain = options.hostDomain ?? constants_1.WA_DEFAULTS.HOST_DOMAIN;
+    }
+    async syncDeviceList(userJids, timeoutMs = this.defaultTimeoutMs) {
+        const normalizedUsers = this.normalizeUsers(userJids);
+        if (normalizedUsers.length === 0) {
+            return [];
+        }
+        const nowMs = Date.now();
+        const cachedByUser = new Map();
+        const usersToQuery = this.deviceListStore
+            ? await this.collectUsersToQuery(normalizedUsers, nowMs, cachedByUser, this.deviceListStore)
+            : normalizedUsers;
+        if (usersToQuery.length === 0) {
+            return normalizedUsers.map((jid) => ({
+                jid,
+                deviceJids: cachedByUser.get(jid) ?? []
+            }));
+        }
+        const request = this.makeDeviceSyncRequest(usersToQuery);
+        this.logger.debug('signal device sync request', {
+            users: usersToQuery.length,
+            timeoutMs
+        });
+        const response = await this.query(request, timeoutMs);
+        const parsed = this.parseDeviceSyncResponse(response, usersToQuery);
+        if (this.deviceListStore) {
+            const updatedAtMs = Date.now();
+            await this.deviceListStore.upsertUserDevicesBatch(parsed.map((entry) => ({
+                userJid: entry.jid,
+                deviceJids: entry.deviceJids,
+                updatedAtMs
+            })));
+        }
+        const parsedByUser = new Map(parsed.map((entry) => [entry.jid, entry.deviceJids]));
+        const merged = normalizedUsers.map((jid) => ({
+            jid,
+            deviceJids: parsedByUser.get(jid) ?? cachedByUser.get(jid) ?? []
+        }));
+        this.logger.debug('signal device sync success', {
+            users: merged.length,
+            devices: merged.reduce((total, entry) => total + entry.deviceJids.length, 0)
+        });
+        return merged;
+    }
+    async collectUsersToQuery(normalizedUsers, nowMs, cachedByUser, store) {
+        const records = await store.getUserDevicesBatch(normalizedUsers, nowMs);
+        const usersToQuery = [];
+        for (let index = 0; index < normalizedUsers.length; index += 1) {
+            const userJid = normalizedUsers[index];
+            const record = records[index];
+            if (!record) {
+                usersToQuery.push(userJid);
+                continue;
+            }
+            cachedByUser.set(userJid, record.deviceJids);
+        }
+        return usersToQuery;
+    }
+    makeDeviceSyncRequest(userJids) {
+        return (0, query_1.buildIqNode)('get', this.hostDomain, constants_1.WA_XMLNS.USYNC, [
+            {
+                tag: constants_1.WA_NODE_TAGS.USYNC,
+                attrs: {
+                    sid: this.makeSid(),
+                    index: '0',
+                    last: 'true',
+                    mode: constants_1.WA_NODE_TAGS.QUERY,
+                    context: 'interactive'
+                },
+                content: [
+                    {
+                        tag: constants_1.WA_NODE_TAGS.QUERY,
+                        attrs: {},
+                        content: [
+                            {
+                                tag: constants_1.WA_NODE_TAGS.DEVICES,
+                                attrs: {
+                                    version: '2'
+                                }
+                            }
+                        ]
+                    },
+                    {
+                        tag: constants_1.WA_NODE_TAGS.LIST,
+                        attrs: {},
+                        content: userJids.map((jid) => ({
+                            tag: constants_1.WA_NODE_TAGS.USER,
+                            attrs: { jid }
+                        }))
+                    }
+                ]
+            }
+        ]);
+    }
+    parseDeviceSyncResponse(node, requestedUsers) {
+        (0, query_1.assertIqResult)(node, 'signal device sync');
+        const usyncNode = (0, helpers_1.findNodeChild)(node, constants_1.WA_NODE_TAGS.USYNC);
+        if (!usyncNode) {
+            throw new Error('signal device sync response missing usync node');
+        }
+        const listNode = (0, helpers_1.findNodeChild)(usyncNode, constants_1.WA_NODE_TAGS.LIST);
+        if (!listNode) {
+            throw new Error('signal device sync response missing list node');
+        }
+        const requestedSet = new Set(requestedUsers);
+        const userNodes = (0, helpers_1.getNodeChildrenByTag)(listNode, constants_1.WA_NODE_TAGS.USER);
+        return userNodes.flatMap((userNode) => {
+            const userJid = userNode.attrs.jid;
+            if (!userJid) {
+                return [];
+            }
+            const normalizedUserJid = this.normalizeUserJid(userJid);
+            if (!requestedSet.has(normalizedUserJid)) {
+                return [];
+            }
+            return [
+                {
+                    jid: normalizedUserJid,
+                    deviceJids: this.parseUserDeviceJids(userNode, normalizedUserJid)
+                }
+            ];
+        });
+    }
+    parseUserDeviceJids(userNode, userJid) {
+        const devicesNode = (0, helpers_1.findNodeChild)(userNode, constants_1.WA_NODE_TAGS.DEVICES);
+        if (!devicesNode) {
+            return [];
+        }
+        const errorNode = (0, helpers_1.findNodeChild)(devicesNode, constants_1.WA_NODE_TAGS.ERROR);
+        if (errorNode) {
+            this.logger.warn('signal device sync user error', {
+                jid: userJid,
+                code: errorNode.attrs.code,
+                text: errorNode.attrs.text
+            });
+            return [];
+        }
+        const deviceListNode = (0, helpers_1.findNodeChild)(devicesNode, 'device-list');
+        if (!deviceListNode) {
+            return [];
+        }
+        return [
+            ...new Set((0, helpers_1.getNodeChildrenByTag)(deviceListNode, 'device')
+                .map((deviceNode) => {
+                const parsedId = deviceNode.attrs.id
+                    ? Number.parseInt(deviceNode.attrs.id, 10)
+                    : Number.NaN;
+                return Number.isSafeInteger(parsedId) && parsedId >= 0
+                    ? this.toDeviceJid(userJid, parsedId)
+                    : null;
+            })
+                .filter((jid) => jid !== null))
+        ];
+    }
+    normalizeUsers(userJids) {
+        return [...new Set(userJids.map((jid) => this.normalizeUserJid(jid)))];
+    }
+    normalizeUserJid(jid) {
+        const { user } = (0, jid_1.parseSignalAddressFromJid)(jid);
+        const { server } = (0, jid_1.splitJid)(jid);
+        return `${user}@${server}`;
+    }
+    toDeviceJid(userJid, deviceId) {
+        const parsed = (0, jid_1.splitJid)(userJid);
+        if (deviceId === 0) {
+            return `${parsed.user}@${parsed.server}`;
+        }
+        return `${parsed.user}:${deviceId}@${parsed.server}`;
+    }
+    makeSid() {
+        return `${Date.now()}.${(0, node_crypto_1.randomInt)(1000000)}`;
+    }
+}
+exports.SignalDeviceSyncApi = SignalDeviceSyncApi;