@nerxa/socketon 0.0.0-stage → 1.21.0

package/src/Utils/reporting-utils.d.ts

@@ -0,0 +1,12 @@
+export function shouldIncludeReportingToken(message: any): boolean;
+export function getMessageReportingToken(msgProtobuf: any, message: any, key: any): Promise<{
+    tag: string;
+    attrs: {};
+    content: {
+        tag: string;
+        attrs: {
+            v: string;
+        };
+        content: any;
+    }[];
+} | null>;

package/src/Utils/reporting-utils.js

@@ -0,0 +1,256 @@
+import { createHmac } from 'crypto';
+import { hkdf } from './crypto.js';
+const reportingFields = [
+    { f: 1 },
+    {
+        f: 3,
+        s: [{ f: 2 }, { f: 3 }, { f: 8 }, { f: 11 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }, { f: 25 }]
+    },
+    { f: 4, s: [{ f: 1 }, { f: 16 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }] },
+    { f: 5, s: [{ f: 3 }, { f: 4 }, { f: 5 }, { f: 16 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }] },
+    { f: 6, s: [{ f: 1 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }, { f: 30 }] },
+    { f: 7, s: [{ f: 2 }, { f: 7 }, { f: 10 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }, { f: 20 }] },
+    { f: 8, s: [{ f: 2 }, { f: 7 }, { f: 9 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }, { f: 21 }] },
+    { f: 9, s: [{ f: 2 }, { f: 6 }, { f: 7 }, { f: 13 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }, { f: 20 }] },
+    { f: 12, s: [{ f: 1 }, { f: 2 }, { f: 14, m: true }, { f: 15 }] },
+    { f: 18, s: [{ f: 6 }, { f: 16 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }] },
+    { f: 26, s: [{ f: 4 }, { f: 5 }, { f: 8 }, { f: 13 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }] },
+    { f: 28, s: [{ f: 1 }, { f: 2 }, { f: 4 }, { f: 5 }, { f: 6 }, { f: 7, s: [{ f: 21 }, { f: 22 }] }] },
+    { f: 37, s: [{ f: 1, m: true }] },
+    {
+        f: 49,
+        s: [
+            { f: 2 },
+            { f: 3, s: [{ f: 1 }, { f: 2 }] },
+            { f: 5, s: [{ f: 21 }, { f: 22 }] },
+            { f: 8, s: [{ f: 1 }, { f: 2 }] }
+        ]
+    },
+    { f: 53, s: [{ f: 1, m: true }] },
+    { f: 55, s: [{ f: 1, m: true }] },
+    { f: 58, s: [{ f: 1, m: true }] },
+    { f: 59, s: [{ f: 1, m: true }] },
+    {
+        f: 60,
+        s: [
+            { f: 2 },
+            { f: 3, s: [{ f: 1 }, { f: 2 }] },
+            { f: 5, s: [{ f: 21 }, { f: 22 }] },
+            { f: 8, s: [{ f: 1 }, { f: 2 }] }
+        ]
+    },
+    {
+        f: 64,
+        s: [
+            { f: 2 },
+            { f: 3, s: [{ f: 1 }, { f: 2 }] },
+            { f: 5, s: [{ f: 21 }, { f: 22 }] },
+            { f: 8, s: [{ f: 1 }, { f: 2 }] }
+        ]
+    },
+    { f: 66, s: [{ f: 2 }, { f: 6 }, { f: 7 }, { f: 13 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }, { f: 20 }] },
+    { f: 74, s: [{ f: 1, m: true }] },
+    { f: 87, s: [{ f: 1, m: true }] },
+    { f: 88, s: [{ f: 1 }, { f: 2, s: [{ f: 1 }] }, { f: 3, s: [{ f: 21 }, { f: 22 }] }] },
+    { f: 92, s: [{ f: 1, m: true }] },
+    { f: 93, s: [{ f: 1, m: true }] },
+    { f: 94, s: [{ f: 1, m: true }] }
+];
+const compileReportingFields = (fields) => {
+    const map = new Map();
+    for (const f of fields) {
+        map.set(f.f, {
+            m: f.m,
+            children: f.s ? compileReportingFields(f.s) : undefined
+        });
+    }
+    return map;
+};
+const compiledReportingFields = compileReportingFields(reportingFields);
+const EMPTY_MAP = new Map();
+const ENC_SECRET_REPORT_TOKEN = 'Report Token';
+const WIRE = {
+    VARINT: 0,
+    FIXED64: 1,
+    BYTES: 2,
+    FIXED32: 5
+};
+export const shouldIncludeReportingToken = (message) => !message.reactionMessage &&
+    !message.encReactionMessage &&
+    !message.encEventResponseMessage &&
+    !message.pollUpdateMessage;
+const generateMsgSecretKey = (modificationType, origMsgId, origMsgSender, modificationSender, origMsgSecret) => {
+    const useCaseSecret = Buffer.concat([
+        Buffer.from(origMsgId, 'utf8'),
+        Buffer.from(origMsgSender, 'utf8'),
+        Buffer.from(modificationSender, 'utf8'),
+        Buffer.from(modificationType, 'utf8')
+    ]);
+    return hkdf(origMsgSecret, 32, { info: useCaseSecret.toString('latin1') });
+};
+const extractReportingTokenContent = (data, cfg) => {
+    const out = [];
+    let i = 0;
+    while (i < data.length) {
+        const tag = decodeVarint(data, i);
+        if (!tag.ok) {
+            return null;
+        }
+        const fieldNum = tag.value >> 3;
+        const wireType = tag.value & 0x7;
+        const fieldStart = i;
+        i += tag.bytes;
+        const fieldCfg = cfg.get(fieldNum);
+        const pushSlice = (end) => {
+            if (end > data.length) {
+                return false;
+            }
+            out.push({ num: fieldNum, bytes: data.subarray(fieldStart, end) });
+            i = end;
+            return true;
+        };
+        const skip = (end) => {
+            if (end > data.length) {
+                return false;
+            }
+            i = end;
+            return true;
+        };
+        if (wireType === WIRE.VARINT) {
+            const v = decodeVarint(data, i);
+            if (!v.ok) {
+                return null;
+            }
+            const end = i + v.bytes;
+            if (!fieldCfg) {
+                if (!skip(end)) {
+                    return null;
+                }
+                continue;
+            }
+            if (!pushSlice(end)) {
+                return null;
+            }
+            continue;
+        }
+        if (wireType === WIRE.FIXED64) {
+            const end = i + 8;
+            if (!fieldCfg) {
+                if (!skip(end)) {
+                    return null;
+                }
+                continue;
+            }
+            if (!pushSlice(end)) {
+                return null;
+            }
+            continue;
+        }
+        if (wireType === WIRE.FIXED32) {
+            const end = i + 4;
+            if (!fieldCfg) {
+                if (!skip(end)) {
+                    return null;
+                }
+                continue;
+            }
+            if (!pushSlice(end)) {
+                return null;
+            }
+            continue;
+        }
+        if (wireType === WIRE.BYTES) {
+            const len = decodeVarint(data, i);
+            if (!len.ok) {
+                return null;
+            }
+            const valStart = i + len.bytes;
+            const valEnd = valStart + len.value;
+            if (valEnd > data.length) {
+                return null;
+            }
+            if (!fieldCfg) {
+                i = valEnd;
+                continue;
+            }
+            if (fieldCfg.m || fieldCfg.children) {
+                const sub = extractReportingTokenContent(data.subarray(valStart, valEnd), fieldCfg.children ?? EMPTY_MAP);
+                if (sub === null) {
+                    return null;
+                }
+                if (sub.length > 0) {
+                    const newTag = encodeVarint(tag.value);
+                    const newLen = encodeVarint(sub.length);
+                    out.push({
+                        num: fieldNum,
+                        bytes: Buffer.concat([newTag, newLen, sub])
+                    });
+                }
+                i = valEnd;
+                continue;
+            }
+            out.push({ num: fieldNum, bytes: data.subarray(fieldStart, valEnd) });
+            i = valEnd;
+            continue;
+        }
+        return null;
+    }
+    if (out.length === 0) {
+        return Buffer.alloc(0);
+    }
+    out.sort((a, b) => a.num - b.num);
+    return Buffer.concat(out.map(f => f.bytes));
+};
+const decodeVarint = (buffer, offset) => {
+    let value = 0;
+    let bytes = 0;
+    let shift = 0;
+    while (offset + bytes < buffer.length) {
+        const current = buffer[offset + bytes];
+        value |= (current & 0x7f) << shift;
+        bytes++;
+        if ((current & 0x80) === 0) {
+            return { value, bytes, ok: true };
+        }
+        shift += 7;
+        if (shift > 35) {
+            return { value: 0, bytes: 0, ok: false };
+        }
+    }
+    return { value: 0, bytes: 0, ok: false };
+};
+const encodeVarint = (value) => {
+    const parts = [];
+    let remaining = value >>> 0;
+    while (remaining > 0x7f) {
+        parts.push((remaining & 0x7f) | 0x80);
+        remaining >>>= 7;
+    }
+    parts.push(remaining);
+    return Buffer.from(parts);
+};
+export const getMessageReportingToken = async (msgProtobuf, message, key) => {
+    const msgSecret = message.messageContextInfo?.messageSecret;
+    if (!msgSecret || !key.id) {
+        return null;
+    }
+    const from = key.fromMe ? key.remoteJid : key.participant || key.remoteJid;
+    const to = key.fromMe ? key.participant || key.remoteJid : key.remoteJid;
+    const reportingSecret = generateMsgSecretKey(ENC_SECRET_REPORT_TOKEN, key.id, from, to, msgSecret);
+    const content = extractReportingTokenContent(msgProtobuf, compiledReportingFields);
+    if (!content || content.length === 0) {
+        return null;
+    }
+    const reportingToken = createHmac('sha256', reportingSecret).update(content).digest().subarray(0, 16);
+    return {
+        tag: 'reporting',
+        attrs: {},
+        content: [
+            {
+                tag: 'reporting_token',
+                attrs: { v: '2' },
+                content: reportingToken
+            }
+        ]
+    };
+};

package/src/Utils/scheduled-message.d.ts

@@ -0,0 +1,51 @@
+import type { proto } from '../../WAProto/index.js'
+
+export declare const SCHEDULED_MSG_META_TYPE: 'scheduled_message'
+export declare const SCHEDULED_MSG_MAX_PER_CHAT: number
+export declare const SCHEDULED_MSG_MAX_MEDIA: number
+export declare const SCHEDULED_MSG_RESOURCE_LIMIT_NACK_CODE: number
+export declare const SCHEDULED_MSG_REVEAL_KEY_BYTES: number
+export declare const SCHEDULED_MSG_REVEAL_KEY_IV_BYTES: number
+export declare const SCHEDULED_MSG_REVEAL_KEY_RETENTION_DAYS: number
+export declare const SCHEDULED_MSG_TAG_BYTES: number
+
+export interface ScheduledMessageWindow {
+    minSeconds: number
+    maxSeconds: number
+}
+
+export declare const SCHEDULED_MSG_WINDOW: Readonly<{
+    chat: ScheduledMessageWindow
+    newsletter: ScheduledMessageWindow
+}>
+
+export declare function generateRevealKey(): Buffer
+export declare function generateRevealKeyId(): string
+export declare function encryptWithRevealKey(plaintext: Uint8Array, revealKey: Uint8Array): {
+    encIv: Buffer
+    encPayload: Buffer
+}
+export declare function decryptWithRevealKey(encPayload: Uint8Array, encIv: Uint8Array, revealKey: Uint8Array): Buffer
+export declare function buildConditionalRevealMessage(input: {
+    encPayload: Uint8Array
+    encIv: Uint8Array
+    revealKeyId: string
+}): { conditionalRevealMessage: proto.Message.IConditionalRevealMessage }
+export declare function encodeScheduledMessage(message: proto.IMessage, revealKey?: Uint8Array): {
+    revealKey: Uint8Array
+    revealKeyId: string
+    encIv: Buffer
+    encPayload: Buffer
+    message: { conditionalRevealMessage: proto.Message.IConditionalRevealMessage }
+}
+export declare function decodeScheduledMessage(conditionalRevealMessage: any, revealKey: Uint8Array): proto.Message
+export declare function buildScheduledMsgMetaNode(input: {
+    kind?: 'schedule' | 'reveal'
+    scheduledTimestampS?: number
+    revealKeyId: string
+    revealKey?: Uint8Array
+}): any
+export declare function buildUnscheduleProtocolMessage(key: proto.IMessageKey): {
+    protocolMessage: proto.Message.IProtocolMessage
+}
+export declare function isScheduledTimeValid(scheduledTimestampS: number, nowSeconds?: number, window?: ScheduledMessageWindow): boolean

package/src/Utils/scheduled-message.js

@@ -0,0 +1,112 @@
+import { createCipheriv, createDecipheriv, randomBytes, randomUUID } from 'crypto'
+import { proto } from '../../WAProto/index.js'
+
+export const SCHEDULED_MSG_META_TYPE = 'scheduled_message'
+export const SCHEDULED_MSG_MAX_PER_CHAT = 30
+export const SCHEDULED_MSG_MAX_MEDIA = 1
+export const SCHEDULED_MSG_RESOURCE_LIMIT_NACK_CODE = 419
+export const SCHEDULED_MSG_REVEAL_KEY_BYTES = 32
+export const SCHEDULED_MSG_REVEAL_KEY_IV_BYTES = 12
+export const SCHEDULED_MSG_REVEAL_KEY_RETENTION_DAYS = 30
+export const SCHEDULED_MSG_TAG_BYTES = 16
+
+export const SCHEDULED_MSG_WINDOW = Object.freeze({
+    chat: { minSeconds: 600, maxSeconds: 1209600 },
+    newsletter: { minSeconds: 600, maxSeconds: 2592000 }
+})
+
+export const generateRevealKey = () => randomBytes(SCHEDULED_MSG_REVEAL_KEY_BYTES)
+
+export const generateRevealKeyId = () => randomUUID()
+
+export const encryptWithRevealKey = (plaintext, revealKey) => {
+    const key = Buffer.from(revealKey)
+    if (key.length !== SCHEDULED_MSG_REVEAL_KEY_BYTES) {
+        throw new TypeError(`reveal key must be ${SCHEDULED_MSG_REVEAL_KEY_BYTES} bytes`)
+    }
+    const encIv = randomBytes(SCHEDULED_MSG_REVEAL_KEY_IV_BYTES)
+    const cipher = createCipheriv('aes-256-gcm', key, encIv)
+    const body = Buffer.concat([cipher.update(Buffer.from(plaintext)), cipher.final()])
+    return { encIv, encPayload: Buffer.concat([body, cipher.getAuthTag()]) }
+}
+
+export const decryptWithRevealKey = (encPayload, encIv, revealKey) => {
+    const key = Buffer.from(revealKey)
+    const payload = Buffer.from(encPayload)
+    if (payload.length < SCHEDULED_MSG_TAG_BYTES) {
+        throw new TypeError('encrypted payload is too short to carry an auth tag')
+    }
+    const decipher = createDecipheriv('aes-256-gcm', key, Buffer.from(encIv))
+    decipher.setAuthTag(payload.subarray(payload.length - SCHEDULED_MSG_TAG_BYTES))
+    return Buffer.concat([
+        decipher.update(payload.subarray(0, payload.length - SCHEDULED_MSG_TAG_BYTES)),
+        decipher.final()
+    ])
+}
+
+export const buildConditionalRevealMessage = ({ encPayload, encIv, revealKeyId }) => ({
+    conditionalRevealMessage: {
+        conditionalRevealMessageType: proto.Message.ConditionalRevealMessage.ConditionalRevealMessageType.SCHEDULED_MESSAGE,
+        encPayload: Buffer.from(encPayload),
+        encIv: Buffer.from(encIv),
+        revealKeyId
+    }
+})
+
+export const encodeScheduledMessage = (message, revealKey = generateRevealKey()) => {
+    const plaintext = proto.Message.encode(proto.Message.fromObject(message)).finish()
+    const { encIv, encPayload } = encryptWithRevealKey(plaintext, revealKey)
+    const revealKeyId = generateRevealKeyId()
+    return {
+        revealKey,
+        revealKeyId,
+        encIv,
+        encPayload,
+        message: buildConditionalRevealMessage({ encPayload, encIv, revealKeyId })
+    }
+}
+
+export const decodeScheduledMessage = (conditionalRevealMessage, revealKey) => {
+    const inner = conditionalRevealMessage?.conditionalRevealMessage ?? conditionalRevealMessage
+    if (!inner?.encPayload || !inner?.encIv) {
+        throw new TypeError('conditionalRevealMessage is missing encPayload or encIv')
+    }
+    return proto.Message.decode(decryptWithRevealKey(inner.encPayload, inner.encIv, revealKey))
+}
+
+export const buildScheduledMsgMetaNode = ({ kind = 'schedule', scheduledTimestampS, revealKeyId, revealKey }) => {
+    if (!revealKeyId) {
+        throw new TypeError('revealKeyId is required')
+    }
+    if (kind === 'schedule' && !revealKey) {
+        throw new TypeError('scheduling requires the reveal key')
+    }
+    const attrs = { type: SCHEDULED_MSG_META_TYPE }
+    if (kind === 'schedule') {
+        if (!Number.isFinite(Number(scheduledTimestampS))) {
+            throw new TypeError('scheduledTimestampS must be a unix timestamp in seconds')
+        }
+        attrs.st = String(Math.floor(Number(scheduledTimestampS)))
+    }
+    return {
+        tag: 'meta',
+        attrs,
+        content: [{
+            tag: 'key',
+            attrs: { rkid: revealKeyId },
+            content: kind === 'schedule' ? Buffer.from(revealKey) : undefined
+        }]
+    }
+}
+
+export const buildUnscheduleProtocolMessage = (key) => ({
+    protocolMessage: {
+        key,
+        type: proto.Message.ProtocolMessage.Type.MESSAGE_UNSCHEDULE
+    }
+})
+
+export const isScheduledTimeValid = (scheduledTimestampS, nowSeconds = Math.floor(Date.now() / 1000), window = SCHEDULED_MSG_WINDOW.chat) => {
+    const rounded = Math.floor(nowSeconds / 60) * 60
+    return scheduledTimestampS - rounded >= window.minSeconds && scheduledTimestampS - nowSeconds <= window.maxSeconds
+}

package/src/Utils/sender-key-memory.d.ts

@@ -0,0 +1,19 @@
+
+export declare function pickSenderKeyRecipients(
+    devices: { jid?: string, device?: number }[],
+    senderKeyMap: Record<string, boolean>,
+    options?: { force?: boolean, skip?: (device: any) => boolean }
+): string[]
+
+export declare function deliveredSenderKeyJids(nodes: { attrs?: { jid?: string } }[]): Set<string>
+
+export declare function senderKeyResetSummary(
+    stored: Record<string, Record<string, boolean> | null | undefined> | undefined,
+    jid: string
+): { jid: string, cleared: number, devices: string[] }
+
+export declare function commitSenderKeyDelivery(
+    senderKeyMap: Record<string, boolean>,
+    recipients: string[],
+    nodes: { attrs?: { jid?: string } }[]
+): { marked: string[], skipped: string[] }

package/src/Utils/sender-key-memory.js

@@ -0,0 +1,51 @@
+
+export const pickSenderKeyRecipients = (devices, senderKeyMap, { force = false, skip } = {}) => {
+    const recipients = []
+    for (const device of devices) {
+        const deviceJid = device?.jid
+        if (!deviceJid) {
+            continue
+        }
+        if (!force && senderKeyMap[deviceJid]) {
+            continue
+        }
+        if (skip && skip(device)) {
+            continue
+        }
+        recipients.push(deviceJid)
+    }
+    return recipients
+}
+
+export const deliveredSenderKeyJids = nodes => {
+    const delivered = new Set()
+    for (const node of nodes || []) {
+        const jid = node?.attrs?.jid
+        if (jid) {
+            delivered.add(jid)
+        }
+    }
+    return delivered
+}
+
+export const senderKeyResetSummary = (stored, jid) => {
+    const devices = Object.keys(stored?.[jid] || {})
+    return { jid, cleared: devices.length, devices }
+}
+
+export const commitSenderKeyDelivery = (senderKeyMap, recipients, nodes) => {
+    const delivered = deliveredSenderKeyJids(nodes)
+    const marked = []
+    const skipped = []
+    for (const jid of recipients) {
+        if (delivered.has(jid)) {
+            senderKeyMap[jid] = true
+            marked.push(jid)
+        }
+        else {
+            delete senderKeyMap[jid]
+            skipped.push(jid)
+        }
+    }
+    return { marked, skipped }
+}

package/src/Utils/signal.d.ts

@@ -0,0 +1,82 @@
+export function createSignalIdentity(wid: any, accountSignatureKey: any): {
+    identifier: {
+        name: any;
+        deviceId: number;
+    };
+    identifierKey: any;
+};
+export function getPreKeys({ get }: {
+    get: any;
+}, min: any, limit: any): Promise<any>;
+export function generateOrGetPreKeys(creds: any, range: any): {
+    newPreKeys: {};
+    lastPreKeyId: number;
+    preKeysRange: any[];
+};
+export function xmppSignedPreKey(key: any): {
+    tag: string;
+    attrs: {};
+    content: {
+        tag: string;
+        attrs: {};
+        content: any;
+    }[];
+};
+export function xmppPreKey(pair: any, id: any): {
+    tag: string;
+    attrs: {};
+    content: {
+        tag: string;
+        attrs: {};
+        content: any;
+    }[];
+};
+export function extractE2ESessionFromRetryReceipt(receipt: any): {
+    registrationId: number | undefined;
+    identityKey: any;
+    signedPreKey: {
+        keyId: number | undefined;
+        publicKey: any;
+        signature: any;
+    };
+    preKey: {
+        keyId: number | undefined;
+        publicKey: any;
+    } | undefined;
+} | null;
+export function parseAndInjectE2ESessions(node: any, repository: any): Promise<void>;
+export function extractDeviceJids(result: any, myJid: any, myLid: any, excludeZeroDevices: any): {
+    user: any;
+    device: any;
+    domainType: any;
+    server: any;
+}[];
+export function getNextPreKeys({ creds, keys }: {
+    creds: any;
+    keys: any;
+}, count: any): Promise<{
+    update: {
+        nextPreKeyId: number;
+        firstUnuploadedPreKeyId: number;
+    };
+    preKeys: any;
+}>;
+export function getNextPreKeysNode(state: any, count: any): Promise<{
+    update: {
+        nextPreKeyId: number;
+        firstUnuploadedPreKeyId: number;
+    };
+    node: {
+        tag: string;
+        attrs: {
+            xmlns: string;
+            type: string;
+            to: string;
+        };
+        content: {
+            tag: string;
+            attrs: {};
+            content: any;
+        }[];
+    };
+}>;