@neelegirl/baileys 1.5.2 → 1.5.3

package/lib/Signal/WASignalGroup/keyhelper.d.ts

@@ -0,0 +1,16 @@
+import { generateKeyPair } from '@neelegirl/libsignal/src/curve'
+
+type KeyPairType = ReturnType<typeof generateKeyPair>
+
+export declare function generateSenderKey(): Buffer
+
+export declare function generateSenderKeyId(): number
+
+export interface SigningKeyPair {
+    public: Buffer
+    private: Buffer
+}
+
+export declare function generateSenderSigningKey(key?: KeyPairType): SigningKeyPair
+
+export {}

package/lib/Signal/WASignalGroup/keyhelper.js

@@ -1,21 +1,66 @@
-const curve = require('@neelegirl/libsignal/src/curve');
-const nodeCrypto = require('crypto');
+"use strict"
 
-exports.generateSenderKey = function() {
-    return nodeCrypto.randomBytes(32);
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k
+    var desc = Object.getOwnPropertyDescriptor(m, k)
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k] } }
+    }
+    Object.defineProperty(o, k2, desc)
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k
+    o[k2] = m[k]
+}))
+
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v })
+}) : function(o, v) {
+    o["default"] = v
+})
+
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = []
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k
+            return ar
+        }
+        return ownKeys(o)
+    }
+    return function (mod) {
+        if (mod && mod.__esModule) return mod
+        var result = {}
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i])
+        __setModuleDefault(result, mod)
+        return result
+    }
+})()
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const nodeCrypto = __importStar(require("crypto"))
+const curve_1 = require("@neelegirl/libsignal/src/curve")
+
+function generateSenderKey() {
+    return nodeCrypto.randomBytes(32)
 }
 
-exports.generateSenderKeyId = function() {
-    return nodeCrypto.randomInt(2147483647);
+function generateSenderKeyId() {
+    return nodeCrypto.randomInt(2147483647)
 }
 
-exports.generateSenderSigningKey = function(key) {
+function generateSenderSigningKey(key) {
     if (!key) {
-        key = curve.generateKeyPair();
+        key = curve_1.generateKeyPair()
     }
-
     return {
-        public: key.pubKey,
-        private: key.privKey,
-    };
-} 
+        public: Buffer.from(key.pubKey),
+        private: Buffer.from(key.privKey)
+    }
+}
+
+module.exports = {
+  generateSenderKey, 
+  generateSenderKeyId, 
+  generateSenderSigningKey
+}

package/lib/Signal/WASignalGroup/protobufs.js

@@ -1,3 +1,3 @@
-const { groupproto } = require('./GroupProtocol')
-
+const { groupproto } = require('./GroupProtocol')
+
 module.exports = groupproto

package/lib/Signal/WASignalGroup/queue_job.js

@@ -1,69 +1,69 @@
-// vim: ts=4:sw=4:expandtab
-
-/*
- * jobQueue manages multiple queues indexed by device to serialize
- * session io ops on the database.
- */
-'use strict';
-
-
-const _queueAsyncBuckets = new Map();
-const _gcLimit = 10000;
-
-async function _asyncQueueExecutor(queue, cleanup) {
-    let offt = 0;
-    while (true) {
-        let limit = Math.min(queue.length, _gcLimit); // Break up thundering hurds for GC duty.
-        for (let i = offt; i < limit; i++) {
-            const job = queue[i];
-            try {
-                job.resolve(await job.awaitable());
-            } catch (e) {
-                job.reject(e);
-            }
-        }
-        if (limit < queue.length) {
-            /* Perform lazy GC of queue for faster iteration. */
-            if (limit >= _gcLimit) {
-                queue.splice(0, limit);
-                offt = 0;
-            } else {
-                offt = limit;
-            }
-        } else {
-            break;
-        }
-    }
-    cleanup();
-}
-
-module.exports = function (bucket, awaitable) {
-    /* Run the async awaitable only when all other async calls registered
-     * here have completed (or thrown).  The bucket argument is a hashable
-     * key representing the task queue to use. */
-    if (!awaitable.name) {
-        // Make debuging easier by adding a name to this function.
-        Object.defineProperty(awaitable, 'name', { writable: true });
-        if (typeof bucket === 'string') {
-            awaitable.name = bucket;
-        } else {
-            console.warn("Unhandled bucket type (for naming):", typeof bucket, bucket);
-        }
-    }
-    let inactive;
-    if (!_queueAsyncBuckets.has(bucket)) {
-        _queueAsyncBuckets.set(bucket, []);
-        inactive = true;
-    }
-    const queue = _queueAsyncBuckets.get(bucket);
-    const job = new Promise((resolve, reject) => queue.push({
-        awaitable,
-        resolve,
-        reject
-    }));
-    if (inactive) {
-        /* An executor is not currently active; Start one now. */
-        _asyncQueueExecutor(queue, () => _queueAsyncBuckets.delete(bucket));
-    }
-    return job;
+// vim: ts=4:sw=4:expandtab
+
+/*
+ * jobQueue manages multiple queues indexed by device to serialize
+ * session io ops on the database.
+ */
+'use strict';
+
+
+const _queueAsyncBuckets = new Map();
+const _gcLimit = 10000;
+
+async function _asyncQueueExecutor(queue, cleanup) {
+    let offt = 0;
+    while (true) {
+        let limit = Math.min(queue.length, _gcLimit); // Break up thundering hurds for GC duty.
+        for (let i = offt; i < limit; i++) {
+            const job = queue[i];
+            try {
+                job.resolve(await job.awaitable());
+            } catch (e) {
+                job.reject(e);
+            }
+        }
+        if (limit < queue.length) {
+            /* Perform lazy GC of queue for faster iteration. */
+            if (limit >= _gcLimit) {
+                queue.splice(0, limit);
+                offt = 0;
+            } else {
+                offt = limit;
+            }
+        } else {
+            break;
+        }
+    }
+    cleanup();
+}
+
+module.exports = function (bucket, awaitable) {
+    /* Run the async awaitable only when all other async calls registered
+     * here have completed (or thrown).  The bucket argument is a hashable
+     * key representing the task queue to use. */
+    if (!awaitable.name) {
+        // Make debuging easier by adding a name to this function.
+        Object.defineProperty(awaitable, 'name', { writable: true });
+        if (typeof bucket === 'string') {
+            awaitable.name = bucket;
+        } else {
+            console.warn("Unhandled bucket type (for naming):", typeof bucket, bucket);
+        }
+    }
+    let inactive;
+    if (!_queueAsyncBuckets.has(bucket)) {
+        _queueAsyncBuckets.set(bucket, []);
+        inactive = true;
+    }
+    const queue = _queueAsyncBuckets.get(bucket);
+    const job = new Promise((resolve, reject) => queue.push({
+        awaitable,
+        resolve,
+        reject
+    }));
+    if (inactive) {
+        /* An executor is not currently active; Start one now. */
+        _asyncQueueExecutor(queue, () => _queueAsyncBuckets.delete(bucket));
+    }
+    return job;
 };

package/lib/Signal/WASignalGroup/readme.md

@@ -1,6 +1,6 @@
-# Signal-Group
-
-This contains the code to decrypt/encrypt WA group messages. 
-Originally from [pokearaujo/libsignal-node](https://github.com/pokearaujo/libsignal-node)
-
+# Signal-Group
+
+This contains the code to decrypt/encrypt WA group messages. 
+Originally from [pokearaujo/libsignal-node](https://github.com/pokearaujo/libsignal-node)
+
 The code has been moved outside the signal package as I felt it didn't belong in ths signal package, as it isn't inherently a part of signal but of WA.

package/lib/Signal/WASignalGroup/sender-chain-key.d.ts

@@ -0,0 +1,14 @@
+import { SenderMessageKey } from './sender-message-key'
+
+export declare class SenderChainKey {
+    private readonly MESSAGE_KEY_SEED
+    private readonly CHAIN_KEY_SEED
+    private readonly iteration
+    private readonly chainKey
+    constructor(iteration: number, chainKey: any)
+    getIteration(): number
+    getSenderMessageKey(): SenderMessageKey
+    getNext(): SenderChainKey
+    getSeed(): Uint8Array
+    private getDerivative
+}

package/lib/Signal/WASignalGroup/sender-chain-key.js

@@ -0,0 +1,47 @@
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const crypto_1 = require("@neelegirl/libsignal/src/crypto")
+const sender_message_key_1 = require("./sender-message-key")
+
+class SenderChainKey {
+    constructor(iteration, chainKey) {
+        this.MESSAGE_KEY_SEED = Buffer.from([0x01])
+        this.CHAIN_KEY_SEED = Buffer.from([0x02])
+        this.iteration = iteration
+        if (Buffer.isBuffer(chainKey)) {
+        	// backported from @MartinSchere's PR
+            this.chainKey = chainKey
+        }
+        else if (chainKey instanceof Uint8Array) {
+            this.chainKey = Buffer.from(chainKey) 
+        }
+        else if (chainKey && typeof chainKey === 'object') {
+            // backported from @MartinSchere (#1741)
+            this.chainKey = Buffer.from(Object.values(chainKey)) // temp fix // backported from @MartinSchere (#1741)
+        }
+        else {
+            this.chainKey = Buffer.alloc(0)
+        }
+    }
+    getIteration() {
+        return this.iteration
+    }
+    getSenderMessageKey() {
+        return new sender_message_key_1.SenderMessageKey(this.iteration, this.getDerivative(this.MESSAGE_KEY_SEED, this.chainKey))
+    }
+    getNext() {
+        return new SenderChainKey(this.iteration + 1, this.getDerivative(this.CHAIN_KEY_SEED, this.chainKey))
+    }
+    getSeed() {
+        return this.chainKey
+    }
+    getDerivative(seed, key) {
+        return (0, crypto_1.calculateMAC)(key, seed)
+    }
+}
+
+module.exports = {
+  SenderChainKey
+}

package/lib/Signal/WASignalGroup/sender-key-distribution-message.d.ts

@@ -0,0 +1,17 @@
+import { CiphertextMessage } from './ciphertext-message'
+
+export declare class SenderKeyDistributionMessage extends CiphertextMessage {
+    private readonly id
+    private readonly iteration
+    private readonly chainKey
+    private readonly signatureKey
+    private readonly serialized
+    constructor(id?: number | null, iteration?: number | null, chainKey?: Uint8Array | null, signatureKey?: Uint8Array | null, serialized?: Uint8Array | null)
+    private intsToByteHighAndLow
+    serialize(): Uint8Array
+    getType(): number
+    getIteration(): number
+    getChainKey(): Uint8Array
+    getSignatureKey(): Uint8Array
+    getId(): number
+}

package/lib/Signal/WASignalGroup/sender-key-distribution-message.js

@@ -0,0 +1,71 @@
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const WAProto_1 = require("../../../WAProto")
+const ciphertext_message_1 = require("./ciphertext-message")
+
+class SenderKeyDistributionMessage extends ciphertext_message_1.CiphertextMessage {
+    constructor(id, iteration, chainKey, signatureKey, serialized) {
+        super()
+        if (serialized) {
+            try {
+                const message = serialized.slice(1)
+                const distributionMessage = WAProto_1.proto.SenderKeyDistributionMessage.decode(message).toJSON()
+                this.serialized = serialized
+                this.id = distributionMessage.id
+                this.iteration = distributionMessage.iteration
+                this.chainKey =
+                    typeof distributionMessage.chainKey === 'string'
+                        ? Buffer.from(distributionMessage.chainKey, 'base64')
+                        : distributionMessage.chainKey
+                this.signatureKey =
+                    typeof distributionMessage.signingKey === 'string'
+                        ? Buffer.from(distributionMessage.signingKey, 'base64')
+                        : distributionMessage.signingKey
+            }
+            catch (e) {
+                throw new Error(String(e))
+            }
+        }
+        else {
+            const version = this.intsToByteHighAndLow(this.CURRENT_VERSION, this.CURRENT_VERSION)
+            this.id = id
+            this.iteration = iteration
+            this.chainKey = chainKey
+            this.signatureKey = signatureKey
+            const message = WAProto_1.proto.SenderKeyDistributionMessage.encode(WAProto_1.proto.SenderKeyDistributionMessage.create({
+                id,
+                iteration,
+                chainKey,
+                signingKey: this.signatureKey
+            })).finish()
+            this.serialized = Buffer.concat([Buffer.from([version]), message])
+        }
+    }
+    intsToByteHighAndLow(highValue, lowValue) {
+        return (((highValue << 4) | lowValue) & 0xff) % 256
+    }
+    serialize() {
+        return this.serialized
+    }
+    getType() {
+        return this.SENDERKEY_DISTRIBUTION_TYPE
+    }
+    getIteration() {
+        return this.iteration
+    }
+    getChainKey() {
+        return typeof this.chainKey === 'string' ? Buffer.from(this.chainKey, 'base64') : this.chainKey
+    }
+    getSignatureKey() {
+        return typeof this.signatureKey === 'string' ? Buffer.from(this.signatureKey, 'base64') : this.signatureKey
+    }
+    getId() {
+        return this.id
+    }
+}
+
+module.exports = {
+  SenderKeyDistributionMessage
+}

package/lib/Signal/WASignalGroup/sender-key-message.d.ts

@@ -0,0 +1,19 @@
+import { CiphertextMessage } from './ciphertext-message'
+
+export declare class SenderKeyMessage extends CiphertextMessage {
+    private readonly SIGNATURE_LENGTH
+    private readonly messageVersion
+    private readonly keyId
+    private readonly iteration
+    private readonly ciphertext
+    private readonly signature
+    private readonly serialized
+    constructor(keyId?: number | null, iteration?: number | null, ciphertext?: Uint8Array | null, signatureKey?: Uint8Array | null, serialized?: Uint8Array | null)
+    getKeyId(): number
+    getIteration(): number
+    getCipherText(): Uint8Array
+    verifySignature(signatureKey: Uint8Array): void
+    private getSignature
+    serialize(): Uint8Array
+    getType(): number
+}

package/lib/Signal/WASignalGroup/sender-key-message.js

@@ -0,0 +1,73 @@
+"use strict"
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const curve_1 = require("@neelegirl/libsignal/src/curve")
+const WAProto_1 = require("../../../WAProto")
+const ciphertext_message_1 = require("./ciphertext-message")
+
+class SenderKeyMessage extends ciphertext_message_1.CiphertextMessage {
+    constructor(keyId, iteration, ciphertext, signatureKey, serialized) {
+        super()
+        this.SIGNATURE_LENGTH = 64
+        if (serialized) {
+            const version = serialized[0]
+            const message = serialized.slice(1, serialized.length - this.SIGNATURE_LENGTH)
+            const signature = serialized.slice(-1 * this.SIGNATURE_LENGTH)
+            const senderKeyMessage = WAProto_1.proto.SenderKeyMessage.decode(message).toJSON()
+            this.serialized = serialized
+            this.messageVersion = (version & 0xff) >> 4
+            this.keyId = senderKeyMessage.id
+            this.iteration = senderKeyMessage.iteration
+            this.ciphertext =
+                typeof senderKeyMessage.ciphertext === 'string'
+                    ? Buffer.from(senderKeyMessage.ciphertext, 'base64')
+                    : senderKeyMessage.ciphertext
+            this.signature = signature
+        }
+        else {
+            const version = (((this.CURRENT_VERSION << 4) | this.CURRENT_VERSION) & 0xff) % 256
+            const ciphertextBuffer = Buffer.from(ciphertext)
+            const message = WAProto_1.proto.SenderKeyMessage.encode(WAProto_1.proto.SenderKeyMessage.create({
+                id: keyId,
+                iteration: iteration,
+                ciphertext: ciphertextBuffer
+            })).finish()
+            const signature = this.getSignature(signatureKey, Buffer.concat([Buffer.from([version]), message]))
+            this.serialized = Buffer.concat([Buffer.from([version]), message, Buffer.from(signature)])
+            this.messageVersion = this.CURRENT_VERSION
+            this.keyId = keyId
+            this.iteration = iteration
+            this.ciphertext = ciphertextBuffer
+            this.signature = signature
+        }
+    }
+    getKeyId() {
+        return this.keyId
+    }
+    getIteration() {
+        return this.iteration
+    }
+    getCipherText() {
+        return this.ciphertext
+    }
+    verifySignature(signatureKey) {
+        const part1 = this.serialized.slice(0, this.serialized.length - this.SIGNATURE_LENGTH)
+        const part2 = this.serialized.slice(-1 * this.SIGNATURE_LENGTH)
+        const res = curve_1.verifySignature(signatureKey, part1, part2)
+        if (!res)
+            throw new Error('Invalid signature!')
+    }
+    getSignature(signatureKey, serialized) {
+        return Buffer.from(curve_1.calculateSignature(signatureKey, serialized))
+    }
+    serialize() {
+        return this.serialized
+    }
+    getType() {
+        return 4
+    }
+}
+
+module.exports = { 
+  SenderKeyMessage
+}

package/lib/Signal/WASignalGroup/sender-key-name.d.ts

@@ -0,0 +1,19 @@
+interface Sender {
+    id: string
+    deviceId: number
+    toString(): string
+}
+
+export declare class SenderKeyName {
+    private readonly groupId
+    private readonly sender
+    constructor(groupId: string, sender: Sender)
+    getGroupId(): string
+    getSender(): Sender
+    serialize(): string
+    toString(): string
+    equals(other: SenderKeyName | null): boolean
+    hashCode(): number
+}
+
+export {}

package/lib/Signal/WASignalGroup/sender-key-name.js

@@ -0,0 +1,59 @@
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+function isNull(str) {
+    return str === null || str === ''
+}
+
+function intValue(num) {
+    const MAX_VALUE = 0x7fffffff
+    const MIN_VALUE = -0x80000000
+    if (num > MAX_VALUE || num < MIN_VALUE) {
+        return num & 0xffffffff
+    }
+   
+ return num
+}
+
+function hashCode(strKey) {
+    let hash = 0
+    if (!isNull(strKey)) {
+        for (let i = 0; i < strKey.length; i++) {
+            hash = hash * 31 + strKey.charCodeAt(i)
+            hash = intValue(hash)
+        }
+    }
+    return hash
+}
+
+class SenderKeyName {
+    constructor(groupId, sender) {
+        this.groupId = groupId
+        this.sender = sender
+    }
+    getGroupId() {
+        return this.groupId
+    }
+    getSender() {
+        return this.sender
+    }
+    serialize() {
+        return `${this.groupId}::${this.sender.id}::${this.sender.deviceId}`
+    }
+    toString() {
+        return this.serialize()
+    }
+    equals(other) {
+        if (other === null)
+            return false
+        return this.groupId === other.groupId && this.sender.toString() === other.sender.toString()
+    }
+    hashCode() {
+        return hashCode(this.groupId) ^ hashCode(this.sender.toString())
+    }
+}
+
+module.exports = {
+  SenderKeyName
+}

package/lib/Signal/WASignalGroup/sender-key-record.d.ts

@@ -0,0 +1,32 @@
+import { SenderKeyState } from './sender-key-state'
+
+export interface SenderKeyStateStructure {
+    senderKeyId: number
+    senderChainKey: {
+        iteration: number
+        seed: Uint8Array
+    }
+    senderSigningKey: {
+        public: Uint8Array
+        private?: Uint8Array
+    }
+    senderMessageKeys: Array<{
+        iteration: number
+        seed: Uint8Array
+    }>
+}
+
+export declare class SenderKeyRecord {
+    private readonly MAX_STATES
+    private readonly senderKeyStates
+    constructor(serialized?: SenderKeyStateStructure[])
+    isEmpty(): boolean
+    getSenderKeyState(keyId?: number): SenderKeyState | undefined
+    addSenderKeyState(id: number, iteration: number, chainKey: Uint8Array, signatureKey: Uint8Array): void
+    setSenderKeyState(id: number, iteration: number, chainKey: Uint8Array, keyPair: {
+        public: Uint8Array
+        private: Uint8Array
+    }): void
+    serialize(): SenderKeyStateStructure[]
+    static deserialize(data: Uint8Array | string | SenderKeyStateStructure[]): SenderKeyRecord
+}

package/lib/Signal/WASignalGroup/sender-key-record.js

@@ -0,0 +1,58 @@
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const generics_1 = require("../../Utils/generics")
+const sender_key_state_1 = require("./sender-key-state")
+
+class SenderKeyRecord {
+    constructor(serialized) {
+        this.MAX_STATES = 5
+        this.senderKeyStates = []
+        if (serialized) {
+            for (const structure of serialized) {
+                this.senderKeyStates.push(new sender_key_state_1.SenderKeyState(null, null, null, null, null, null, structure))
+            }
+        }
+    }
+    isEmpty() {
+        return this.senderKeyStates.length === 0
+    }
+    getSenderKeyState(keyId) {
+        if (keyId === undefined && this.senderKeyStates.length) {
+            return this.senderKeyStates[this.senderKeyStates.length - 1]
+        }
+        return this.senderKeyStates.find(state => state.getKeyId() === keyId)
+    }
+    addSenderKeyState(id, iteration, chainKey, signatureKey) {
+        this.senderKeyStates.push(new sender_key_state_1.SenderKeyState(id, iteration, chainKey, null, signatureKey))
+        if (this.senderKeyStates.length > this.MAX_STATES) {
+            this.senderKeyStates.shift()
+        }
+    }
+    setSenderKeyState(id, iteration, chainKey, keyPair) {
+        this.senderKeyStates.length = 0
+        this.senderKeyStates.push(new sender_key_state_1.SenderKeyState(id, iteration, chainKey, keyPair))
+    }
+    serialize() {
+        return this.senderKeyStates.map(state => state.getStructure())
+    }
+    static deserialize(data) {
+        let parsed
+        if (typeof data === 'string') {
+            parsed = JSON.parse(data, generics_1.BufferJSON.reviver)
+        }
+        else if (data instanceof Uint8Array) {
+            const str = Buffer.from(data).toString('utf-8')
+            parsed = JSON.parse(str, generics_1.BufferJSON.reviver)
+        }
+        else {
+            parsed = data
+        }
+        return new SenderKeyRecord(parsed)
+    }
+}
+
+module.exports = {
+  SenderKeyRecord
+}