gifted-baileys 1.5.4 → 1.5.6

package/src/Tests/test.libsignal.ts

@@ -0,0 +1,186 @@
+import { makeLibSignalRepository } from '../Signal/libsignal'
+import { SignalAuthState, SignalDataTypeMap } from '../Types'
+import { Curve, generateRegistrationId, generateSignalPubKey, signedKeyPair } from '../Utils'
+
+describe('Signal Tests', () => {
+
+	it('should correctly encrypt/decrypt 1 message', async() => {
+		const user1 = makeUser()
+		const user2 = makeUser()
+
+		const msg = Buffer.from('hello there!')
+
+		await prepareForSendingMessage(user1, user2)
+
+		const result = await user1.repository.encryptMessage(
+			{ jid: user2.jid, data: msg }
+		)
+
+		const dec = await user2.repository.decryptMessage(
+			{ jid: user1.jid, ...result }
+		)
+
+		expect(dec).toEqual(msg)
+	})
+
+	it('should correctly override a session', async() => {
+		const user1 = makeUser()
+		const user2 = makeUser()
+
+		const msg = Buffer.from('hello there!')
+
+		for(let preKeyId = 2; preKeyId <= 3;preKeyId++) {
+			await prepareForSendingMessage(user1, user2, preKeyId)
+
+			const result = await user1.repository.encryptMessage(
+				{ jid: user2.jid, data: msg }
+			)
+
+			const dec = await user2.repository.decryptMessage(
+				{ jid: user1.jid, ...result }
+			)
+
+			expect(dec).toEqual(msg)
+		}
+	})
+
+	it('should correctly encrypt/decrypt multiple messages', async() => {
+		const user1 = makeUser()
+		const user2 = makeUser()
+
+		const msg = Buffer.from('hello there!')
+
+		await prepareForSendingMessage(user1, user2)
+
+		for(let i = 0;i < 10;i++) {
+			const result = await user1.repository.encryptMessage(
+				{ jid: user2.jid, data: msg }
+			)
+
+			const dec = await user2.repository.decryptMessage(
+				{ jid: user1.jid, ...result }
+			)
+
+			expect(dec).toEqual(msg)
+		}
+	})
+
+	it('should encrypt/decrypt messages from group', async() => {
+		const groupId = '123456@g.us'
+		const participants = [...Array(5)].map(makeUser)
+
+		const msg = Buffer.from('hello there!')
+
+		const sender = participants[0]
+		const enc = await sender.repository.encryptGroupMessage(
+			{
+				group: groupId,
+				meId: sender.jid,
+				data: msg
+			}
+		)
+
+		for(const participant of participants) {
+			if(participant === sender) {
+				continue
+			}
+
+			await participant.repository.processSenderKeyDistributionMessage(
+				{
+					item: {
+						groupId,
+						axolotlSenderKeyDistributionMessage: enc.senderKeyDistributionMessage
+					},
+					authorJid: sender.jid
+				}
+			)
+
+			const dec = await participant.repository.decryptGroupMessage(
+				{
+					group: groupId,
+					authorJid: sender.jid,
+					msg: enc.ciphertext
+				}
+			)
+			expect(dec).toEqual(msg)
+		}
+	})
+})
+
+type User = ReturnType<typeof makeUser>
+
+function makeUser() {
+	const store = makeTestAuthState()
+	const jid = `${Math.random().toString().replace('.', '')}@s.whatsapp.net`
+	const repository = makeLibSignalRepository(store)
+	return { store, jid, repository }
+}
+
+async function prepareForSendingMessage(
+	sender: User,
+	receiver: User,
+	preKeyId = 2
+) {
+	const preKey = Curve.generateKeyPair()
+	await sender.repository.injectE2ESession(
+		{
+			jid: receiver.jid,
+			session: {
+				registrationId: receiver.store.creds.registrationId,
+				identityKey: generateSignalPubKey(receiver.store.creds.signedIdentityKey.public),
+				signedPreKey: {
+					keyId: receiver.store.creds.signedPreKey.keyId,
+					publicKey: generateSignalPubKey(receiver.store.creds.signedPreKey.keyPair.public),
+					signature: receiver.store.creds.signedPreKey.signature,
+				},
+				preKey: {
+					keyId: preKeyId,
+					publicKey: generateSignalPubKey(preKey.public),
+				}
+			}
+		}
+	)
+
+	await receiver.store.keys.set({
+		'pre-key': {
+			[preKeyId]: preKey
+		}
+	})
+}
+
+function makeTestAuthState(): SignalAuthState {
+	const identityKey = Curve.generateKeyPair()
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	const store: { [_: string]: any } = {}
+	return {
+		creds: {
+			signedIdentityKey: identityKey,
+			registrationId: generateRegistrationId(),
+			signedPreKey: signedKeyPair(identityKey, 1),
+		},
+		keys: {
+			get(type, ids) {
+				const data: { [_: string]: SignalDataTypeMap[typeof type] } = { }
+				for(const id of ids) {
+					const item = store[getUniqueId(type, id)]
+					if(typeof item !== 'undefined') {
+						data[id] = item
+					}
+				}
+
+				return data
+			},
+			set(data) {
+				for(const type in data) {
+					for(const id in data[type]) {
+						store[getUniqueId(type, id)] = data[type][id]
+					}
+				}
+			},
+		}
+	}
+
+	function getUniqueId(type: string, id: string) {
+		return `${type}.${id}`
+	}
+}

package/src/Tests/test.media-download.js

@@ -0,0 +1,93 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const WAProto_1 = require("../../WAProto");
+const Utils_1 = require("../Utils");
+jest.setTimeout(20000);
+const TEST_VECTORS = [
+    {
+        type: 'image',
+        message: WAProto_1.proto.Message.ImageMessage.decode(Buffer.from('Ck1odHRwczovL21tZy53aGF0c2FwcC5uZXQvZC9mL0FwaHR4WG9fWXZZcDZlUVNSa0tjOHE5d2ozVUpleWdoY3poM3ExX3I0ektnLmVuYxIKaW1hZ2UvanBlZyIgKTuVFyxDc6mTm4GXPlO3Z911Wd8RBeTrPLSWAEdqW8MomcUBQiB7wH5a4nXMKyLOT0A2nFgnnM/DUH8YjQf8QtkCIekaSkogTB+BXKCWDFrmNzozY0DCPn0L4VKd7yG1ZbZwbgRhzVc=', 'base64')),
+        plaintext: (0, fs_1.readFileSync)('./Media/cat.jpeg')
+    },
+    {
+        type: 'image',
+        message: WAProto_1.proto.Message.ImageMessage.decode(Buffer.from('Ck1odHRwczovL21tZy53aGF0c2FwcC5uZXQvZC9mL0Ftb2tnWkphNWF6QWZxa3dVRzc0eUNUdTlGeWpjMmd5akpqcXNmMUFpZEU5LmVuYxIKaW1hZ2UvanBlZyIg8IS5TQzdzcuvcR7F8HMhWnXmlsV+GOo9JE1/t2k+o9Yoz6o6QiA7kDk8j5KOEQC0kDFE1qW7lBBDYhm5z06N3SirfUj3CUog/CjYF8e670D5wUJwWv2B2mKzDEo8IJLStDv76YmtPfs=', 'base64')),
+        plaintext: (0, fs_1.readFileSync)('./Media/icon.png')
+    },
+];
+describe('Media Download Tests', () => {
+    it('should download a full encrypted media correctly', () => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, e_1, _b, _c;
+        for (const { type, message, plaintext } of TEST_VECTORS) {
+            const readPipe = yield (0, Utils_1.downloadContentFromMessage)(message, type);
+            let buffer = Buffer.alloc(0);
+            try {
+                for (var _d = true, readPipe_1 = (e_1 = void 0, __asyncValues(readPipe)), readPipe_1_1; readPipe_1_1 = yield readPipe_1.next(), _a = readPipe_1_1.done, !_a; _d = true) {
+                    _c = readPipe_1_1.value;
+                    _d = false;
+                    const read = _c;
+                    buffer = Buffer.concat([buffer, read]);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = readPipe_1.return)) yield _b.call(readPipe_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            expect(buffer).toEqual(plaintext);
+        }
+    }));
+    it('should download an encrypted media correctly piece', () => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, e_2, _b, _c;
+        for (const { type, message, plaintext } of TEST_VECTORS) {
+            // check all edge cases
+            const ranges = [
+                { startByte: 51, endByte: plaintext.length - 100 }, // random numbers
+                { startByte: 1024, endByte: 2038 }, // larger random multiples of 16
+                { startByte: 1, endByte: plaintext.length - 1 } // borders
+            ];
+            for (const range of ranges) {
+                const readPipe = yield (0, Utils_1.downloadContentFromMessage)(message, type, range);
+                let buffer = Buffer.alloc(0);
+                try {
+                    for (var _d = true, readPipe_2 = (e_2 = void 0, __asyncValues(readPipe)), readPipe_2_1; readPipe_2_1 = yield readPipe_2.next(), _a = readPipe_2_1.done, !_a; _d = true) {
+                        _c = readPipe_2_1.value;
+                        _d = false;
+                        const read = _c;
+                        buffer = Buffer.concat([buffer, read]);
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = readPipe_2.return)) yield _b.call(readPipe_2);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+                const hex = buffer.toString('hex');
+                const expectedHex = plaintext.slice(range.startByte || 0, range.endByte || undefined).toString('hex');
+                expect(hex).toBe(expectedHex);
+                console.log('success on ', range);
+            }
+        }
+    }));
+});

package/src/Tests/test.media-download.ts

@@ -0,0 +1,76 @@
+import { readFileSync } from 'fs'
+import { proto } from '../../WAProto'
+import { DownloadableMessage, MediaType } from '../Types'
+import { downloadContentFromMessage } from '../Utils'
+
+jest.setTimeout(20_000)
+
+type TestVector = {
+	type: MediaType
+	message: DownloadableMessage
+	plaintext: Buffer
+}
+
+const TEST_VECTORS: TestVector[] = [
+	{
+		type: 'image',
+		message: proto.Message.ImageMessage.decode(
+			Buffer.from(
+				'Ck1odHRwczovL21tZy53aGF0c2FwcC5uZXQvZC9mL0FwaHR4WG9fWXZZcDZlUVNSa0tjOHE5d2ozVUpleWdoY3poM3ExX3I0ektnLmVuYxIKaW1hZ2UvanBlZyIgKTuVFyxDc6mTm4GXPlO3Z911Wd8RBeTrPLSWAEdqW8MomcUBQiB7wH5a4nXMKyLOT0A2nFgnnM/DUH8YjQf8QtkCIekaSkogTB+BXKCWDFrmNzozY0DCPn0L4VKd7yG1ZbZwbgRhzVc=',
+				'base64'
+			)
+		),
+		plaintext: readFileSync('./Media/cat.jpeg')
+	},
+	{
+		type: 'image',
+		message: proto.Message.ImageMessage.decode(
+			Buffer.from(
+				'Ck1odHRwczovL21tZy53aGF0c2FwcC5uZXQvZC9mL0Ftb2tnWkphNWF6QWZxa3dVRzc0eUNUdTlGeWpjMmd5akpqcXNmMUFpZEU5LmVuYxIKaW1hZ2UvanBlZyIg8IS5TQzdzcuvcR7F8HMhWnXmlsV+GOo9JE1/t2k+o9Yoz6o6QiA7kDk8j5KOEQC0kDFE1qW7lBBDYhm5z06N3SirfUj3CUog/CjYF8e670D5wUJwWv2B2mKzDEo8IJLStDv76YmtPfs=',
+				'base64'
+			)
+		),
+		plaintext: readFileSync('./Media/icon.png')
+	},
+]
+
+describe('Media Download Tests', () => {
+
+	it('should download a full encrypted media correctly', async() => {
+		for(const { type, message, plaintext } of TEST_VECTORS) {
+			const readPipe = await downloadContentFromMessage(message, type)
+
+			let buffer = Buffer.alloc(0)
+			for await (const read of readPipe) {
+				buffer = Buffer.concat([ buffer, read ])
+			}
+
+			expect(buffer).toEqual(plaintext)
+		}
+	})
+
+	it('should download an encrypted media correctly piece', async() => {
+		for(const { type, message, plaintext } of TEST_VECTORS) {
+			// check all edge cases
+			const ranges = [
+				{ startByte: 51, endByte: plaintext.length - 100 }, // random numbers
+				{ startByte: 1024, endByte: 2038 }, // larger random multiples of 16
+				{ startByte: 1, endByte: plaintext.length - 1 } // borders
+			]
+			for(const range of ranges) {
+				const readPipe = await downloadContentFromMessage(message, type, range)
+
+				let buffer = Buffer.alloc(0)
+				for await (const read of readPipe) {
+					buffer = Buffer.concat([ buffer, read ])
+				}
+
+				const hex = buffer.toString('hex')
+				const expectedHex = plaintext.slice(range.startByte || 0, range.endByte || undefined).toString('hex')
+				expect(hex).toBe(expectedHex)
+
+				console.log('success on ', range)
+			}
+		}
+	})
+})

package/src/Tests/test.messages.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Utils_1 = require("../Utils");
+describe('Messages Tests', () => {
+    it('should correctly unwrap messages', () => {
+        const CONTENT = { imageMessage: {} };
+        expectRightContent(CONTENT);
+        expectRightContent({
+            ephemeralMessage: { message: CONTENT }
+        });
+        expectRightContent({
+            viewOnceMessage: {
+                message: {
+                    ephemeralMessage: { message: CONTENT }
+                }
+            }
+        });
+        expectRightContent({
+            viewOnceMessage: {
+                message: {
+                    viewOnceMessageV2: {
+                        message: {
+                            ephemeralMessage: { message: CONTENT }
+                        }
+                    }
+                }
+            }
+        });
+        function expectRightContent(content) {
+            expect((0, Utils_1.normalizeMessageContent)(content)).toHaveProperty('imageMessage');
+        }
+    });
+});

package/src/Tests/test.messages.ts

@@ -0,0 +1,37 @@
+import { WAMessageContent } from '../Types'
+import { normalizeMessageContent } from '../Utils'
+
+describe('Messages Tests', () => {
+
+	it('should correctly unwrap messages', () => {
+		const CONTENT = { imageMessage: { } }
+		expectRightContent(CONTENT)
+		expectRightContent({
+			ephemeralMessage: { message: CONTENT }
+		})
+		expectRightContent({
+			viewOnceMessage: {
+				message: {
+					ephemeralMessage: { message: CONTENT }
+				}
+			}
+		})
+		expectRightContent({
+			viewOnceMessage: {
+				message: {
+					viewOnceMessageV2: {
+						message: {
+							ephemeralMessage: { message: CONTENT }
+						}
+					}
+				}
+			}
+		})
+
+		function expectRightContent(content: WAMessageContent) {
+			expect(
+				normalizeMessageContent(content)
+			).toHaveProperty('imageMessage')
+		}
+	})
+})

package/src/Tests/utils.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomJid = randomJid;
+exports.makeMockSignalKeyStore = makeMockSignalKeyStore;
+const WABinary_1 = require("../WABinary");
+function randomJid() {
+    return (0, WABinary_1.jidEncode)(Math.floor(Math.random() * 1000000), Math.random() < 0.5 ? 's.whatsapp.net' : 'g.us');
+}
+function makeMockSignalKeyStore() {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const store = {};
+    return {
+        get(type, ids) {
+            const data = {};
+            for (const id of ids) {
+                const item = store[getUniqueId(type, id)];
+                if (typeof item !== 'undefined') {
+                    data[id] = item;
+                }
+            }
+            return data;
+        },
+        set(data) {
+            for (const type in data) {
+                for (const id in data[type]) {
+                    store[getUniqueId(type, id)] = data[type][id];
+                }
+            }
+        },
+    };
+    function getUniqueId(type, id) {
+        return `${type}.${id}`;
+    }
+}

package/src/Tests/utils.ts

@@ -0,0 +1,36 @@
+import { SignalDataTypeMap, SignalKeyStore } from '../Types'
+import { jidEncode } from '../WABinary'
+
+export function randomJid() {
+	return jidEncode(Math.floor(Math.random() * 1000000), Math.random() < 0.5 ? 's.whatsapp.net' : 'g.us')
+}
+
+export function makeMockSignalKeyStore(): SignalKeyStore {
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	const store: { [_: string]: any } = {}
+
+	return {
+		get(type, ids) {
+			const data: { [_: string]: SignalDataTypeMap[typeof type] } = { }
+			for(const id of ids) {
+				const item = store[getUniqueId(type, id)]
+				if(typeof item !== 'undefined') {
+					data[id] = item
+				}
+			}
+
+			return data
+		},
+		set(data) {
+			for(const type in data) {
+				for(const id in data[type]) {
+					store[getUniqueId(type, id)] = data[type][id]
+				}
+			}
+		},
+	}
+
+	function getUniqueId(type: string, id: string) {
+		return `${type}.${id}`
+	}
+}

package/src/Types/Auth.ts

@@ -0,0 +1,113 @@
+import type { proto } from '../../WAProto'
+import { RegistrationOptions } from '../Socket/registration'
+import type { Contact } from './Contact'
+import type { MinimalMessage } from './Message'
+
+export type KeyPair = { public: Uint8Array, private: Uint8Array }
+export type SignedKeyPair = {
+    keyPair: KeyPair
+    signature: Uint8Array
+    keyId: number
+    timestampS?: number
+}
+
+export type ProtocolAddress = {
+	name: string // jid
+	deviceId: number
+}
+export type SignalIdentity = {
+	identifier: ProtocolAddress
+	identifierKey: Uint8Array
+}
+
+export type LTHashState = {
+    version: number
+    hash: Buffer
+    indexValueMap: {
+        [indexMacBase64: string]: { valueMac: Uint8Array | Buffer }
+    }
+}
+
+export type SignalCreds = {
+    readonly signedIdentityKey: KeyPair
+    readonly signedPreKey: SignedKeyPair
+    readonly registrationId: number
+}
+
+export type AccountSettings = {
+    /** unarchive chats when a new message is received */
+    unarchiveChats: boolean
+    /** the default mode to start new conversations with */
+    defaultDisappearingMode?: Pick<proto.IConversation, 'ephemeralExpiration' | 'ephemeralSettingTimestamp'>
+}
+
+export type AuthenticationCreds = SignalCreds & {
+    readonly noiseKey: KeyPair
+    readonly pairingEphemeralKeyPair: KeyPair
+    advSecretKey: string
+
+    me?: Contact
+    account?: proto.IADVSignedDeviceIdentity
+    signalIdentities?: SignalIdentity[]
+    myAppStateKeyId?: string
+    firstUnuploadedPreKeyId: number
+    nextPreKeyId: number
+
+    lastAccountSyncTimestamp?: number
+    platform?: string
+
+    processedHistoryMessages: MinimalMessage[]
+    /** number of times history & app state has been synced */
+    accountSyncCounter: number
+    accountSettings: AccountSettings
+	// mobile creds
+	deviceId: string
+	phoneId: string
+	identityId: Buffer
+	registered: boolean
+	backupToken: Buffer
+	registration: RegistrationOptions
+    pairingCode: string | undefined
+    lastPropHash: string | undefined
+    routingInfo: Buffer | undefined
+}
+
+export type SignalDataTypeMap = {
+    'pre-key': KeyPair
+    'session': Uint8Array
+    'sender-key': Uint8Array
+    'sender-key-memory': { [jid: string]: boolean }
+    'app-state-sync-key': proto.Message.IAppStateSyncKeyData
+    'app-state-sync-version': LTHashState
+}
+
+export type SignalDataSet = { [T in keyof SignalDataTypeMap]?: { [id: string]: SignalDataTypeMap[T] | null } }
+
+type Awaitable<T> = T | Promise<T>
+
+export type SignalKeyStore = {
+    get<T extends keyof SignalDataTypeMap>(type: T, ids: string[]): Awaitable<{ [id: string]: SignalDataTypeMap[T] }>
+    set(data: SignalDataSet): Awaitable<void>
+    /** clear all the data in the store */
+    clear?(): Awaitable<void>
+}
+
+export type SignalKeyStoreWithTransaction = SignalKeyStore & {
+    isInTransaction: () => boolean
+    transaction<T>(exec: () => Promise<T>): Promise<T>
+}
+
+export type TransactionCapabilityOptions = {
+	maxCommitRetries: number
+	delayBetweenTriesMs: number
+}
+
+export type SignalAuthState = {
+    creds: SignalCreds
+    keys: SignalKeyStore | SignalKeyStoreWithTransaction
+}
+
+export type AuthenticationState = {
+    creds: AuthenticationCreds
+    keys: SignalKeyStore
+}

package/src/Types/Call.ts

@@ -0,0 +1,15 @@
+
+export type WACallUpdateType = 'offer' | 'ringing' | 'timeout' | 'reject' | 'accept'
+
+export type WACallEvent = {
+	chatId: string
+	from: string
+	isGroup?: boolean
+	groupJid?: string
+	id: string
+	date: Date
+	isVideo?: boolean
+	status: WACallUpdateType
+	offline: boolean
+	latencyMs?: number
+}