@neelegirl/baileys 1.5.3 → 1.5.4

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

@@ -1,73 +0,0 @@
-"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

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

@@ -1,59 +0,0 @@
-"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

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

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

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

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

@@ -1,147 +0,0 @@
-"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

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

@@ -1,33 +0,0 @@
-"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 +0,0 @@
-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 +0,0 @@
-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;