@neelegirl/baileys 1.5.2 → 1.5.3

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

@@ -0,0 +1,44 @@
+import { SenderChainKey } from './sender-chain-key'
+import { SenderMessageKey } from './sender-message-key'
+
+interface SenderChainKeyStructure {
+    iteration: number
+    seed: Uint8Array
+}
+
+interface SenderSigningKeyStructure {
+    public: Uint8Array
+    private?: Uint8Array
+}
+
+interface SenderMessageKeyStructure {
+    iteration: number
+    seed: Uint8Array
+}
+
+interface SenderKeyStateStructure {
+    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, 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 {}

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

@@ -0,0 +1,147 @@
+"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
+        
+        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
+            }
+            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: senderChainKeyStructure,
+                senderSigningKey: signingKeyStructure,
+                senderMessageKeys: []
+            }
+        }
+    }
+    getKeyId() {
+        return this.senderKeyStateStructure.senderKeyId
+    }
+    getSenderChainKey() {
+        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() {
+        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
+        }
+        
+        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 || [])
+    }
+    hasSenderMessageKey(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()
+        }
+    }
+    removeSenderMessageKey(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)
+        }
+        return null
+    }
+    getStructure() {
+        return this.senderKeyStateStructure
+    }
+}
+
+module.exports = {
+  SenderKeyState
+}

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

@@ -0,0 +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
+}

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

@@ -0,0 +1,33 @@
+"use strict"
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const crypto_1 = require("@neelegirl/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
+    }
+    getIteration() {
+        return this.iteration
+    }
+    getIv() {
+        return this.iv
+    }
+    getCipherKey() {
+        return this.cipherKey
+    }
+    getSeed() {
+        return this.seed
+    }
+}
+
+module.exports = {
+  SenderMessageKey
+}

package/lib/Signal/WASignalGroup/sender_chain_key.js

@@ -1,50 +1,50 @@
-const SenderMessageKey = require('./sender_message_key');
-//const HKDF = require('./hkdf');
-const crypto = require('@neelegirl/libsignal/src/crypto');
-
-class SenderChainKey {
-  MESSAGE_KEY_SEED = Buffer.from([0x01]);
-
-  CHAIN_KEY_SEED = Buffer.from([0x02]);
-
-  iteration = 0;
-
-  chainKey = Buffer.alloc(0);
-
-  constructor(iteration, chainKey) {
-    this.iteration = iteration;
-    this.chainKey = chainKey;
-  }
-
-  getIteration() {
-    return this.iteration;
-  }
-
-  getSenderMessageKey() {
-    return new 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 typeof this.chainKey === 'string' ? Buffer.from(this.chainKey, 'base64') : this.chainKey;
-  }
-
-  getDerivative(seed, key) {
-    key = typeof key === 'string' ? Buffer.from(key, 'base64') : key;
-    const hash = crypto.calculateMAC(key, seed);
-    //const hash = new Hash().hmac_hash(key, seed, 'sha256', '');
-    
-    return hash;
-  }
-}
-
+const SenderMessageKey = require('./sender_message_key');
+//const HKDF = require('./hkdf');
+const crypto = require('@neelegirl/libsignal/src/crypto');
+
+class SenderChainKey {
+  MESSAGE_KEY_SEED = Buffer.from([0x01]);
+
+  CHAIN_KEY_SEED = Buffer.from([0x02]);
+
+  iteration = 0;
+
+  chainKey = Buffer.alloc(0);
+
+  constructor(iteration, chainKey) {
+    this.iteration = iteration;
+    this.chainKey = chainKey;
+  }
+
+  getIteration() {
+    return this.iteration;
+  }
+
+  getSenderMessageKey() {
+    return new 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 typeof this.chainKey === 'string' ? Buffer.from(this.chainKey, 'base64') : this.chainKey;
+  }
+
+  getDerivative(seed, key) {
+    key = typeof key === 'string' ? Buffer.from(key, 'base64') : key;
+    const hash = crypto.calculateMAC(key, seed);
+    //const hash = new Hash().hmac_hash(key, seed, 'sha256', '');
+    
+    return hash;
+  }
+}
+
 module.exports = SenderChainKey;

package/lib/Signal/WASignalGroup/sender_key_distribution_message.js

@@ -1,78 +1,78 @@
-const CiphertextMessage = require('./ciphertext_message');
-const protobufs = require('./protobufs');
-
-class SenderKeyDistributionMessage extends CiphertextMessage {
-  constructor(
-    id = null,
-    iteration = null,
-    chainKey = null,
-    signatureKey = null,
-    serialized = null
-  ) {
-    super();
-    if (serialized) {
-      try {
-        const version = serialized[0];
-        const message = serialized.slice(1);
-
-        const distributionMessage = protobufs.SenderKeyDistributionMessage.decode(
-          message
-        ).toJSON();
-        this.serialized = serialized;
-        this.id = distributionMessage.id;
-        this.iteration = distributionMessage.iteration;
-        this.chainKey = distributionMessage.chainKey;
-        this.signatureKey = distributionMessage.signingKey;
-      } catch (e) {
-        throw new Error(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 = protobufs.SenderKeyDistributionMessage.encode(
-        protobufs.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;
-  }
-}
-
+const CiphertextMessage = require('./ciphertext_message');
+const protobufs = require('./protobufs');
+
+class SenderKeyDistributionMessage extends CiphertextMessage {
+  constructor(
+    id = null,
+    iteration = null,
+    chainKey = null,
+    signatureKey = null,
+    serialized = null
+  ) {
+    super();
+    if (serialized) {
+      try {
+        const version = serialized[0];
+        const message = serialized.slice(1);
+
+        const distributionMessage = protobufs.SenderKeyDistributionMessage.decode(
+          message
+        ).toJSON();
+        this.serialized = serialized;
+        this.id = distributionMessage.id;
+        this.iteration = distributionMessage.iteration;
+        this.chainKey = distributionMessage.chainKey;
+        this.signatureKey = distributionMessage.signingKey;
+      } catch (e) {
+        throw new Error(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 = protobufs.SenderKeyDistributionMessage.encode(
+        protobufs.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.js

@@ -1,92 +1,92 @@
-const CiphertextMessage = require('./ciphertext_message');
-const curve = require('@neelegirl/libsignal/src/curve');
-const protobufs = require('./protobufs');
-
-class SenderKeyMessage extends CiphertextMessage {
-  SIGNATURE_LENGTH = 64;
-
-  constructor(
-    keyId = null,
-    iteration = null,
-    ciphertext = null,
-    signatureKey = null,
-    serialized = null
-  ) {
-    super();
-    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 = protobufs.SenderKeyMessage.decode(message).toJSON();
-      senderKeyMessage.ciphertext = Buffer.from(senderKeyMessage.ciphertext, 'base64');
-
-      this.serialized = serialized;
-      this.messageVersion = (version & 0xff) >> 4;
-
-      this.keyId = senderKeyMessage.id;
-      this.iteration = senderKeyMessage.iteration;
-      this.ciphertext = senderKeyMessage.ciphertext;
-      this.signature = signature;
-    } else {
-      const version = (((this.CURRENT_VERSION << 4) | this.CURRENT_VERSION) & 0xff) % 256;
-      ciphertext = Buffer.from(ciphertext); // .toString('base64');
-      const message = protobufs.SenderKeyMessage.encode(
-        protobufs.SenderKeyMessage.create({
-          id: keyId,
-          iteration,
-          ciphertext,
-        })
-      ).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 = ciphertext;
-      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.verifySignature(signatureKey, part1, part2);
-    if (!res) throw new Error('Invalid signature!');
-  }
-
-  getSignature(signatureKey, serialized) {
-    const signature = Buffer.from(
-      curve.calculateSignature(
-        signatureKey,
-        serialized
-      )
-    );
-    return signature;
-  }
-
-  serialize() {
-    return this.serialized;
-  }
-
-  getType() {
-    return 4;
-  }
-}
-
+const CiphertextMessage = require('./ciphertext_message');
+const curve = require('@neelegirl/libsignal/src/curve');
+const protobufs = require('./protobufs');
+
+class SenderKeyMessage extends CiphertextMessage {
+  SIGNATURE_LENGTH = 64;
+
+  constructor(
+    keyId = null,
+    iteration = null,
+    ciphertext = null,
+    signatureKey = null,
+    serialized = null
+  ) {
+    super();
+    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 = protobufs.SenderKeyMessage.decode(message).toJSON();
+      senderKeyMessage.ciphertext = Buffer.from(senderKeyMessage.ciphertext, 'base64');
+
+      this.serialized = serialized;
+      this.messageVersion = (version & 0xff) >> 4;
+
+      this.keyId = senderKeyMessage.id;
+      this.iteration = senderKeyMessage.iteration;
+      this.ciphertext = senderKeyMessage.ciphertext;
+      this.signature = signature;
+    } else {
+      const version = (((this.CURRENT_VERSION << 4) | this.CURRENT_VERSION) & 0xff) % 256;
+      ciphertext = Buffer.from(ciphertext); // .toString('base64');
+      const message = protobufs.SenderKeyMessage.encode(
+        protobufs.SenderKeyMessage.create({
+          id: keyId,
+          iteration,
+          ciphertext,
+        })
+      ).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 = ciphertext;
+      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.verifySignature(signatureKey, part1, part2);
+    if (!res) throw new Error('Invalid signature!');
+  }
+
+  getSignature(signatureKey, serialized) {
+    const signature = Buffer.from(
+      curve.calculateSignature(
+        signatureKey,
+        serialized
+      )
+    );
+    return signature;
+  }
+
+  serialize() {
+    return this.serialized;
+  }
+
+  getType() {
+    return 4;
+  }
+}
+
 module.exports = SenderKeyMessage;