@pontalabs/baileys 1.0.10 → 1.1.0

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

@@ -1,73 +1,78 @@
-"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 {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const {
+    verifySignature: verifySignature,
+    calculateSignature: calculateSignature,
+} = require("libsignal/src/curve");
+const { proto: proto } = require("../../../WAProto");
+const { CiphertextMessage: CiphertextMessage } = require("./ciphertext-message");
+class SenderKeyMessage extends 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 = WAProto_1.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 = proto.SenderKeyMessage.decode(message).toJSON();
+            this.serialized = serialized;
+            this.messageVersion = (version & 255) >> 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
+                typeof senderKeyMessage.ciphertext === "string"
+                    ? Buffer.from(senderKeyMessage.ciphertext, "base64")
+                    : senderKeyMessage.ciphertext;
+            this.signature = signature;
+        } else {
+            const version = (((this.CURRENT_VERSION << 4) | this.CURRENT_VERSION) & 255) % 256;
+            const ciphertextBuffer = Buffer.from(ciphertext);
+            const message = proto.SenderKeyMessage.encode(
+                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
+        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 = curve_1.verifySignature(signatureKey, part1, part2)
-        if (!res)
-            throw new Error('Invalid signature!')
+        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);
+        if (!res) throw new Error("Invalid signature!");
     }
     getSignature(signatureKey, serialized) {
-        return Buffer.from(curve_1.calculateSignature(signatureKey, serialized))
+        return Buffer.from(calculateSignature(signatureKey, serialized));
     }
     serialize() {
-        return this.serialized
+        return this.serialized;
     }
     getType() {
-        return 4
+        return 4;
     }
 }
-
-module.exports = { 
-  SenderKeyMessage
-}
+module.exports = { SenderKeyMessage: SenderKeyMessage };

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

@@ -1,59 +1,49 @@
-"use strict"
-
-Object.defineProperty(exports, "__esModule", { value: true })
-
+"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 = 2147483647;
+    const MIN_VALUE = -2147483648;
     if (num > MAX_VALUE || num < MIN_VALUE) {
-        return num & 0xffffffff
+        return num & 4294967295;
     }
-   
- 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;
 }
-
 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()
+        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())
+        return hashCode(this.groupId) ^ hashCode(this.sender.toString());
     }
 }
-
-module.exports = {
-  SenderKeyName
-}
+module.exports = { SenderKeyName: SenderKeyName };

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

@@ -1,58 +1,45 @@
-"use strict"
-
-Object.defineProperty(exports, "__esModule", { value: true })
-
-const generics_1 = require("../../Utils/generics")
-const sender_key_state_1 = require("./sender-key-state")
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const { BufferJSON: BufferJSON } = require("../../Utils/generics");
+const { SenderKeyState: SenderKeyState } = 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 sender_key_state_1.SenderKeyState(null, null, null, null, null, null, structure))
+                this.senderKeyStates.push(
+                    new 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 sender_key_state_1.SenderKeyState(id, iteration, chainKey, null, signatureKey))
+        this.senderKeyStates.push(new 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 sender_key_state_1.SenderKeyState(id, iteration, chainKey, keyPair))
+        this.senderKeyStates.length = 0;
+        this.senderKeyStates.push(new SenderKeyState(id, iteration, chainKey, keyPair));
     }
     serialize() {
-        return this.senderKeyStates.map(state => state.getStructure())
+        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)
+        const str = Buffer.from(data).toString("utf-8");
+        const parsed = JSON.parse(str, BufferJSON.reviver);
+        return new SenderKeyRecord(parsed);
     }
 }
-
-module.exports = {
-  SenderKeyRecord
-}
+module.exports = { SenderKeyRecord: SenderKeyRecord };

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

@@ -1,147 +1,100 @@
-"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")
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const { SenderChainKey: SenderChainKey } = require("./sender-chain-key");
+const { SenderMessageKey: SenderMessageKey } = require("./sender-message-key");
 class SenderKeyState {
-    constructor(id, iteration, chainKey, signatureKeyPair, signatureKeyPublic, signatureKeyPrivate, senderKeyStateStructure) {
-        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)
-        }
-        
+    constructor(
+        id,
+        iteration,
+        chainKey,
+        signatureKeyPair,
+        signatureKeyPublic,
+        signatureKeyPrivate,
+        senderKeyStateStructure
+    ) {
+        this.MAX_MESSAGE_KEYS = 2e3;
         if (senderKeyStateStructure) {
             this.senderKeyStateStructure = {
                 ...senderKeyStateStructure,
                 senderMessageKeys: Array.isArray(senderKeyStateStructure.senderMessageKeys)
                     ? senderKeyStateStructure.senderMessageKeys
-                    : []
-            }
-        }
-        else {
+                    : [],
+            };
+        } else {
             if (signatureKeyPair) {
-                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
+                signatureKeyPublic = signatureKeyPair.public;
+                signatureKeyPrivate = signatureKeyPair.private;
             }
-            
             this.senderKeyStateStructure = {
                 senderKeyId: id || 0,
-                senderChainKey: senderChainKeyStructure,
-                senderSigningKey: signingKeyStructure,
-                senderMessageKeys: []
-            }
+                senderChainKey: {
+                    iteration: iteration || 0,
+                    seed: Buffer.from(chainKey || []),
+                },
+                senderSigningKey: {
+                    public: Buffer.from(signatureKeyPublic || []),
+                    private: Buffer.from(signatureKeyPrivate || []),
+                },
+                senderMessageKeys: [],
+            };
         }
     }
     getKeyId() {
-        return this.senderKeyStateStructure.senderKeyId
+        return this.senderKeyStateStructure.senderKeyId;
     }
     getSenderChainKey() {
-        return new sender_chain_key_1.SenderChainKey(this.senderKeyStateStructure.senderChainKey.iteration, this.senderKeyStateStructure.senderChainKey.seed)
+        return new SenderChainKey(
+            this.senderKeyStateStructure.senderChainKey.iteration,
+            this.senderKeyStateStructure.senderChainKey.seed
+        );
     }
     setSenderChainKey(chainKey) {
         this.senderKeyStateStructure.senderChainKey = {
             iteration: chainKey.getIteration(),
-            seed: chainKey.getSeed()
-        }
+            seed: chainKey.getSeed(),
+        };
     }
     getSigningKeyPublic() {
-        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
-        
+        const publicKey = Buffer.from(this.senderKeyStateStructure.senderSigningKey.public);
         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] = 5;
+            publicKey.copy(fixed, 1);
+            return fixed;
         }
-        
-        return publicKey
+        return publicKey;
     }
     getSigningKeyPrivate() {
-        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 || [])
+        const privateKey = this.senderKeyStateStructure.senderSigningKey.private;
+        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()
-        })
-        
+            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 sender_message_key_1.SenderMessageKey(messageKey.iteration, messageKey.seed)
+            const messageKey = this.senderKeyStateStructure.senderMessageKeys[index];
+            this.senderKeyStateStructure.senderMessageKeys.splice(index, 1);
+            return new SenderMessageKey(messageKey.iteration, messageKey.seed);
         }
-        return null
+        return null;
     }
     getStructure() {
-        return this.senderKeyStateStructure
+        return this.senderKeyStateStructure;
     }
 }
-
-module.exports = {
-  SenderKeyState
-}
+module.exports = { SenderKeyState: SenderKeyState };

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

@@ -1,33 +1,28 @@
-"use strict"
-Object.defineProperty(exports, "__esModule", { value: true })
-
-const crypto_1 = require("libsignal/src/crypto")
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const { deriveSecrets: deriveSecrets } = require("libsignal/src/crypto");
 class SenderMessageKey {
     constructor(iteration, seed) {
-        const derivative = (0, crypto_1.deriveSecrets)(seed, Buffer.alloc(32), Buffer.from('WhisperGroup'))
-        const keys = new Uint8Array(32)
-        keys.set(new Uint8Array(derivative[0].slice(16)))
-        keys.set(new Uint8Array(derivative[1].slice(0, 16)), 16)
-        this.iv = Buffer.from(derivative[0].slice(0, 16))
-        this.cipherKey = Buffer.from(keys.buffer)
-        this.iteration = iteration
-        this.seed = seed
+        const derivative = deriveSecrets(seed, Buffer.alloc(32), Buffer.from("WhisperGroup"));
+        const keys = new Uint8Array(32);
+        keys.set(new Uint8Array(derivative[0].slice(16)));
+        keys.set(new Uint8Array(derivative[1].slice(0, 16)), 16);
+        this.iv = Buffer.from(derivative[0].slice(0, 16));
+        this.cipherKey = Buffer.from(keys.buffer);
+        this.iteration = iteration;
+        this.seed = seed;
     }
     getIteration() {
-        return this.iteration
+        return this.iteration;
     }
     getIv() {
-        return this.iv
+        return this.iv;
     }
     getCipherKey() {
-        return this.cipherKey
+        return this.cipherKey;
     }
     getSeed() {
-        return this.seed
+        return this.seed;
     }
 }
-
-module.exports = {
-  SenderMessageKey
-}
+module.exports = { SenderMessageKey: SenderMessageKey };