@pontalabs/baileys 1.0.6 → 1.0.8

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

@@ -1,66 +1,73 @@
-import { calculateSignature, verifySignature } from 'libsignal/src/curve.js';
-import { proto } from '../../../WAProto/index.js';
-import { CiphertextMessage } from './ciphertext-message.js';
-export class SenderKeyMessage extends CiphertextMessage {
+"use strict"
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const curve_1 = require("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;
+        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 = proto.SenderKeyMessage.decode(message).toJSON();
-            this.serialized = serialized;
-            this.messageVersion = (version & 0xff) >> 4;
-            this.keyId = senderKeyMessage.id;
-            this.iteration = senderKeyMessage.iteration;
+            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;
+                    : senderKeyMessage.ciphertext
+            this.signature = signature
         }
         else {
-            const version = (((this.CURRENT_VERSION << 4) | this.CURRENT_VERSION) & 0xff) % 256;
-            const ciphertextBuffer = Buffer.from(ciphertext);
-            const message = proto.SenderKeyMessage.encode(proto.SenderKeyMessage.create({
+            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;
+            })).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;
+        return this.keyId
     }
     getIteration() {
-        return this.iteration;
+        return this.iteration
     }
     getCipherText() {
-        return this.ciphertext;
+        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 = verifySignature(signatureKey, part1, part2);
+        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!');
+            throw new Error('Invalid signature!')
     }
     getSignature(signatureKey, serialized) {
-        return Buffer.from(calculateSignature(signatureKey, serialized));
+        return Buffer.from(curve_1.calculateSignature(signatureKey, serialized))
     }
     serialize() {
-        return this.serialized;
+        return this.serialized
     }
     getType() {
-        return 4;
+        return 4
     }
 }
-//# sourceMappingURL=sender-key-message.js.map
+
+module.exports = { 
+  SenderKeyMessage
+}

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

@@ -1,18 +1,19 @@
 interface Sender {
-    id: string;
-    deviceId: number;
-    toString(): string;
+    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;
+    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 {};
-//# sourceMappingURL=sender-key-name.d.ts.map
+
+export {}

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

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

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

@@ -1,31 +1,32 @@
-import { SenderKeyState } from './sender-key-state.js';
+import { SenderKeyState } from './sender-key-state'
+
 export interface SenderKeyStateStructure {
-    senderKeyId: number;
+    senderKeyId: number
     senderChainKey: {
-        iteration: number;
-        seed: Uint8Array;
-    };
+        iteration: number
+        seed: Uint8Array
+    }
     senderSigningKey: {
-        public: Uint8Array;
-        private?: Uint8Array;
-    };
+        public: Uint8Array
+        private?: Uint8Array
+    }
     senderMessageKeys: Array<{
-        iteration: number;
-        seed: Uint8Array;
-    }>;
+        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;
+    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): SenderKeyRecord;
-}
-//# sourceMappingURL=sender-key-record.d.ts.map
+        public: Uint8Array
+        private: Uint8Array
+    }): void
+    serialize(): SenderKeyStateStructure[]
+    static deserialize(data: Uint8Array | string | SenderKeyStateStructure[]): SenderKeyRecord
+}

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

@@ -1,41 +1,58 @@
-import { BufferJSON } from '../../Utils/generics.js';
-import { SenderKeyState } from './sender-key-state.js';
-export class SenderKeyRecord {
+"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 = [];
+        this.MAX_STATES = 5
+        this.senderKeyStates = []
         if (serialized) {
             for (const structure of serialized) {
-                this.senderKeyStates.push(new SenderKeyState(null, null, null, null, null, null, structure));
+                this.senderKeyStates.push(new sender_key_state_1.SenderKeyState(null, null, null, null, null, null, structure))
             }
         }
     }
     isEmpty() {
-        return this.senderKeyStates.length === 0;
+        return this.senderKeyStates.length === 0
     }
     getSenderKeyState(keyId) {
         if (keyId === undefined && this.senderKeyStates.length) {
-            return this.senderKeyStates[this.senderKeyStates.length - 1];
+            return this.senderKeyStates[this.senderKeyStates.length - 1]
         }
-        return this.senderKeyStates.find(state => state.getKeyId() === keyId);
+        return this.senderKeyStates.find(state => state.getKeyId() === keyId)
     }
     addSenderKeyState(id, iteration, chainKey, signatureKey) {
-        this.senderKeyStates.push(new SenderKeyState(id, iteration, chainKey, null, 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();
+            this.senderKeyStates.shift()
         }
     }
     setSenderKeyState(id, iteration, chainKey, keyPair) {
-        this.senderKeyStates.length = 0;
-        this.senderKeyStates.push(new SenderKeyState(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());
+        return this.senderKeyStates.map(state => state.getStructure())
     }
     static deserialize(data) {
-        const str = Buffer.from(data).toString('utf-8');
-        const parsed = JSON.parse(str, BufferJSON.reviver);
-        return new SenderKeyRecord(parsed);
+        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)
     }
 }
-//# sourceMappingURL=sender-key-record.js.map
+
+module.exports = {
+  SenderKeyRecord
+}

package/lib/Signal/Group/sender-key-state.d.ts

@@ -1,39 +1,44 @@
-import { SenderChainKey } from './sender-chain-key.js';
-import { SenderMessageKey } from './sender-message-key.js';
+import { SenderChainKey } from './sender-chain-key'
+import { SenderMessageKey } from './sender-message-key'
+
 interface SenderChainKeyStructure {
-    iteration: number;
-    seed: Uint8Array;
+    iteration: number
+    seed: Uint8Array
 }
+
 interface SenderSigningKeyStructure {
-    public: Uint8Array;
-    private?: Uint8Array;
+    public: Uint8Array
+    private?: Uint8Array
 }
+
 interface SenderMessageKeyStructure {
-    iteration: number;
-    seed: Uint8Array;
+    iteration: number
+    seed: Uint8Array
 }
+
 interface SenderKeyStateStructure {
-    senderKeyId: number;
-    senderChainKey: SenderChainKeyStructure;
-    senderSigningKey: SenderSigningKeyStructure;
-    senderMessageKeys: SenderMessageKeyStructure[];
+    senderKeyId: number
+    senderChainKey: SenderChainKeyStructure
+    senderSigningKey: SenderSigningKeyStructure
+    senderMessageKeys: SenderMessageKeyStructure[]
 }
+
 export declare class SenderKeyState {
-    private readonly MAX_MESSAGE_KEYS;
-    private readonly senderKeyStateStructure;
-    constructor(id?: number | null, iteration?: number | null, chainKey?: Uint8Array | null | string, signatureKeyPair?: {
-        public: Uint8Array | string;
-        private: Uint8Array | string;
-    } | null, signatureKeyPublic?: Uint8Array | string | null, signatureKeyPrivate?: Uint8Array | string | null, senderKeyStateStructure?: SenderKeyStateStructure | null);
-    getKeyId(): number;
-    getSenderChainKey(): SenderChainKey;
-    setSenderChainKey(chainKey: SenderChainKey): void;
-    getSigningKeyPublic(): Buffer;
-    getSigningKeyPrivate(): Buffer | undefined;
-    hasSenderMessageKey(iteration: number): boolean;
-    addSenderMessageKey(senderMessageKey: SenderMessageKey): void;
-    removeSenderMessageKey(iteration: number): SenderMessageKey | null;
-    getStructure(): SenderKeyStateStructure;
+    private readonly MAX_MESSAGE_KEYS
+    private readonly senderKeyStateStructure
+    constructor(id?: number | null, iteration?: number | null, chainKey?: Uint8Array | null, signatureKeyPair?: {
+        public: Uint8Array
+        private: Uint8Array
+    } | null, signatureKeyPublic?: Uint8Array | null, signatureKeyPrivate?: Uint8Array | null, senderKeyStateStructure?: SenderKeyStateStructure | null)
+    getKeyId(): number
+    getSenderChainKey(): SenderChainKey
+    setSenderChainKey(chainKey: SenderChainKey): void
+    getSigningKeyPublic(): Buffer
+    getSigningKeyPrivate(): Buffer | undefined
+    hasSenderMessageKey(iteration: number): boolean
+    addSenderMessageKey(senderMessageKey: SenderMessageKey): void
+    removeSenderMessageKey(iteration: number): SenderMessageKey | null
+    getStructure(): SenderKeyStateStructure
 }
-export {};
-//# sourceMappingURL=sender-key-state.d.ts.map
+
+export {}

package/lib/Signal/Group/sender-key-state.js

@@ -1,84 +1,147 @@
-import { SenderChainKey } from './sender-chain-key.js';
-import { SenderMessageKey } from './sender-message-key.js';
-export class SenderKeyState {
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const sender_chain_key_1 = require("./sender-chain-key")
+const sender_message_key_1 = require("./sender-message-key")
+
+class SenderKeyState {
     constructor(id, iteration, chainKey, signatureKeyPair, signatureKeyPublic, signatureKeyPrivate, senderKeyStateStructure) {
-        this.MAX_MESSAGE_KEYS = 2000;
+        this.MAX_MESSAGE_KEYS = 2000
+        
+        const toBuffer = (val) => {
+            if (!val)
+                return Buffer.alloc(0)
+            if (typeof val === 'string')
+                return Buffer.from(val, 'base64')
+            if (val instanceof Uint8Array || Array.isArray(val))
+                return Buffer.from(val)
+            return Buffer.alloc(0)
+        }
+        
         if (senderKeyStateStructure) {
             this.senderKeyStateStructure = {
                 ...senderKeyStateStructure,
                 senderMessageKeys: Array.isArray(senderKeyStateStructure.senderMessageKeys)
                     ? senderKeyStateStructure.senderMessageKeys
                     : []
-            };
+            }
         }
         else {
             if (signatureKeyPair) {
-                signatureKeyPublic = signatureKeyPair.public;
-                signatureKeyPrivate = signatureKeyPair.private;
+                signatureKeyPublic = signatureKeyPair.public
+                signatureKeyPrivate = signatureKeyPair.private
+            }
+            chainKey = typeof chainKey === 'string' ? Buffer.from(chainKey, 'base64') : chainKey
+            
+            const senderChainKeyStructure = {
+                iteration: iteration || 0,
+                seed: chainKey ? toBuffer(chainKey) : Buffer.alloc(0)
+            }
+            
+            const signingKeyStructure = {
+                public: toBuffer(signatureKeyPublic),
+                private: signatureKeyPrivate ? toBuffer(signatureKeyPrivate) : undefined
             }
+            
             this.senderKeyStateStructure = {
                 senderKeyId: id || 0,
-                senderChainKey: {
-                    iteration: iteration || 0,
-                    seed: Buffer.from(chainKey || [])
-                },
-                senderSigningKey: {
-                    public: Buffer.from(signatureKeyPublic || []),
-                    private: Buffer.from(signatureKeyPrivate || [])
-                },
+                senderChainKey: senderChainKeyStructure,
+                senderSigningKey: signingKeyStructure,
                 senderMessageKeys: []
-            };
+            }
         }
     }
     getKeyId() {
-        return this.senderKeyStateStructure.senderKeyId;
+        return this.senderKeyStateStructure.senderKeyId
     }
     getSenderChainKey() {
-        return new SenderChainKey(this.senderKeyStateStructure.senderChainKey.iteration, this.senderKeyStateStructure.senderChainKey.seed);
+        return new sender_chain_key_1.SenderChainKey(this.senderKeyStateStructure.senderChainKey.iteration, this.senderKeyStateStructure.senderChainKey.seed)
     }
     setSenderChainKey(chainKey) {
         this.senderKeyStateStructure.senderChainKey = {
             iteration: chainKey.getIteration(),
             seed: chainKey.getSeed()
-        };
+        }
     }
     getSigningKeyPublic() {
-        const publicKey = Buffer.from(this.senderKeyStateStructure.senderSigningKey.public);
+        let key = this.senderKeyStateStructure.senderSigningKey.public
+        
+        // normalize into Buffer
+        if (!Buffer.isBuffer(key)) {
+            if (key instanceof Uint8Array) {
+                key = Buffer.from(key)
+            }
+            else if (typeof key === 'string') {
+                key = Buffer.from(key, 'base64')
+            }
+            else if (key && typeof key === 'object') {
+                return Buffer.from(Object.values(key)) // temp fix // inspired by @MartinSchere 's #1741
+            }
+            else {
+                key = Buffer.from(key || [])
+            }
+        }
+        
+        const publicKey = key
+        
         if (publicKey.length === 32) {
-            const fixed = Buffer.alloc(33);
-            fixed[0] = 0x05;
-            publicKey.copy(fixed, 1);
-            return fixed;
+            const fixed = Buffer.alloc(33)
+            
+            fixed[0] = 0x05
+            publicKey.copy(fixed, 1)
+            
+            return fixed
         }
-        return publicKey;
+        
+        return publicKey
     }
     getSigningKeyPrivate() {
-        const privateKey = this.senderKeyStateStructure.senderSigningKey.private;
-        return Buffer.from(privateKey || []);
+        const privateKey = this.senderKeyStateStructure.senderSigningKey.private
+        if (!privateKey) {
+            return undefined
+        }
+        if (Buffer.isBuffer(privateKey)) {
+            return privateKey
+        }
+        else if (privateKey instanceof Uint8Array) {
+            return Buffer.from(privateKey)
+        }
+        else if (privateKey && typeof privateKey === 'object') {
+            return Buffer.from(Object.values(privateKey)) // temp fix // inspired by @MartinSchere 's #1741
+        }
+        else if (typeof privateKey === 'string') {
+            return Buffer.from(privateKey, 'base64')
+        }
+        return Buffer.from(privateKey || [])
     }
     hasSenderMessageKey(iteration) {
-        return this.senderKeyStateStructure.senderMessageKeys.some(key => key.iteration === iteration);
+        return this.senderKeyStateStructure.senderMessageKeys.some(key => key.iteration === iteration)
     }
     addSenderMessageKey(senderMessageKey) {
         this.senderKeyStateStructure.senderMessageKeys.push({
             iteration: senderMessageKey.getIteration(),
             seed: senderMessageKey.getSeed()
-        });
+        })
+        
         if (this.senderKeyStateStructure.senderMessageKeys.length > this.MAX_MESSAGE_KEYS) {
-            this.senderKeyStateStructure.senderMessageKeys.shift();
+            this.senderKeyStateStructure.senderMessageKeys.shift()
         }
     }
     removeSenderMessageKey(iteration) {
-        const index = this.senderKeyStateStructure.senderMessageKeys.findIndex(key => key.iteration === iteration);
+        const index = this.senderKeyStateStructure.senderMessageKeys.findIndex(key => key.iteration === iteration)
         if (index !== -1) {
-            const messageKey = this.senderKeyStateStructure.senderMessageKeys[index];
-            this.senderKeyStateStructure.senderMessageKeys.splice(index, 1);
-            return new SenderMessageKey(messageKey.iteration, messageKey.seed);
+            const messageKey = this.senderKeyStateStructure.senderMessageKeys[index]
+            this.senderKeyStateStructure.senderMessageKeys.splice(index, 1)
+            return new sender_message_key_1.SenderMessageKey(messageKey.iteration, messageKey.seed)
         }
-        return null;
+        return null
     }
     getStructure() {
-        return this.senderKeyStateStructure;
+        return this.senderKeyStateStructure
     }
 }
-//# sourceMappingURL=sender-key-state.js.map
+
+module.exports = {
+  SenderKeyState
+}

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

@@ -1,12 +1,11 @@
 export declare class SenderMessageKey {
-    private readonly iteration;
-    private readonly iv;
-    private readonly cipherKey;
-    private readonly seed;
-    constructor(iteration: number, seed: Uint8Array);
-    getIteration(): number;
-    getIv(): Uint8Array;
-    getCipherKey(): Uint8Array;
-    getSeed(): Uint8Array;
-}
-//# sourceMappingURL=sender-message-key.d.ts.map
+    private readonly iteration
+    private readonly iv
+    private readonly cipherKey
+    private readonly seed
+    constructor(iteration: number, seed: Uint8Array)
+    getIteration(): number
+    getIv(): Uint8Array
+    getCipherKey(): Uint8Array
+    getSeed(): Uint8Array
+}