dcodeindra-baileyspro 2.3.9

package/lib/Signal/Group/index.js

@@ -0,0 +1,61 @@
+"use strict"
+
+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 })
+exports.keyhelper = exports.CiphertextMessage = exports.SenderChainKey = exports.SenderMessageKey = exports.SenderKeyMessage = exports.SenderKeyState = exports.GroupCipher = exports.SenderKeyName = exports.SenderKeyRecord = exports.SenderKeyDistributionMessage = exports.GroupSessionBuilder = void 0
+var group_session_builder_1 = require("./group-session-builder")
+Object.defineProperty(exports, "GroupSessionBuilder", { enumerable: true, get: function () { return group_session_builder_1.GroupSessionBuilder } })
+var sender_key_distribution_message_1 = require("./sender-key-distribution-message")
+Object.defineProperty(exports, "SenderKeyDistributionMessage", { enumerable: true, get: function () { return sender_key_distribution_message_1.SenderKeyDistributionMessage } })
+var sender_key_record_1 = require("./sender-key-record")
+Object.defineProperty(exports, "SenderKeyRecord", { enumerable: true, get: function () { return sender_key_record_1.SenderKeyRecord } })
+var sender_key_name_1 = require("./sender-key-name")
+Object.defineProperty(exports, "SenderKeyName", { enumerable: true, get: function () { return sender_key_name_1.SenderKeyName } })
+var group_cipher_1 = require("./group_cipher")
+Object.defineProperty(exports, "GroupCipher", { enumerable: true, get: function () { return group_cipher_1.GroupCipher } })
+var sender_key_state_1 = require("./sender-key-state")
+Object.defineProperty(exports, "SenderKeyState", { enumerable: true, get: function () { return sender_key_state_1.SenderKeyState } })
+var sender_key_message_1 = require("./sender-key-message")
+Object.defineProperty(exports, "SenderKeyMessage", { enumerable: true, get: function () { return sender_key_message_1.SenderKeyMessage } })
+var sender_message_key_1 = require("./sender-message-key")
+Object.defineProperty(exports, "SenderMessageKey", { enumerable: true, get: function () { return sender_message_key_1.SenderMessageKey } })
+var sender_chain_key_1 = require("./sender-chain-key")
+Object.defineProperty(exports, "SenderChainKey", { enumerable: true, get: function () { return sender_chain_key_1.SenderChainKey } })
+var ciphertext_message_1 = require("./ciphertext-message")
+Object.defineProperty(exports, "CiphertextMessage", { enumerable: true, get: function () { return ciphertext_message_1.CiphertextMessage } })
+exports.keyhelper = __importStar(require("./keyhelper"))

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

@@ -0,0 +1,16 @@
+import { generateKeyPair } from '@itsukichan/libsignal-node/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/Group/keyhelper.js

@@ -0,0 +1,66 @@
+"use strict"
+
+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("@itsukichan/libsignal-node/src/curve")
+
+function generateSenderKey() {
+    return nodeCrypto.randomBytes(32)
+}
+
+function generateSenderKeyId() {
+    return nodeCrypto.randomInt(2147483647)
+}
+
+function generateSenderSigningKey(key) {
+    if (!key) {
+        key = curve_1.generateKeyPair()
+    }
+    return {
+        public: Buffer.from(key.pubKey),
+        private: Buffer.from(key.privKey)
+    }
+}
+
+module.exports = {
+  generateSenderKey, 
+  generateSenderKeyId, 
+  generateSenderSigningKey
+}

package/lib/Signal/Group/queue-job.d.ts

@@ -0,0 +1 @@
+export function queueJob<T>(bucket: string | number, awaitable: () => Promise<T>): Promise<T>

package/lib/Signal/Group/queue-job.js

@@ -0,0 +1,64 @@
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const _queueAsyncBuckets = new Map()
+const _gcLimit = 10000
+
+async function _asyncQueueExecutor(queue, cleanup) {
+    let offt = 0
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const limit = Math.min(queue.length, _gcLimit)
+        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) {
+            if (limit >= _gcLimit) {
+                queue.splice(0, limit)
+                offt = 0
+            }
+            else {
+                offt = limit
+            }
+        }
+        else {
+            break
+        }
+    }
+    cleanup()
+}
+
+function queueJob(bucket, awaitable) {
+    // Skip name assignment since it's readonly in strict mode
+    if (typeof bucket !== 'string') {
+        console.warn('Unhandled bucket type (for naming):', typeof bucket, bucket)
+    }
+    let inactive = false
+    if (!_queueAsyncBuckets.has(bucket)) {
+        _queueAsyncBuckets.set(bucket, [])
+        inactive = true
+    }
+    const queue = _queueAsyncBuckets.get(bucket)
+    const job = new Promise((resolve, reject) => {
+        queue.push({
+            awaitable,
+            resolve: resolve,
+            reject
+        })
+    })
+    if (inactive) {
+        _asyncQueueExecutor(queue, () => _queueAsyncBuckets.delete(bucket))
+    }
+    return job
+}
+
+module.exports = {
+  queueJob
+}

package/lib/Signal/Group/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/Group/sender-chain-key.js

@@ -0,0 +1,39 @@
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const crypto_1 = require("@itsukichan/libsignal-node/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 (chainKey instanceof Buffer) {
+            this.chainKey = chainKey
+        }
+        else {
+            this.chainKey = Buffer.from(chainKey || [])
+        }
+    }
+    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/Group/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/Group/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/Group/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/Group/sender-key-message.js

@@ -0,0 +1,73 @@
+"use strict"
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const curve_1 = require("@itsukichan/libsignal-node/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/Group/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/Group/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/Group/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/Group/sender-key-record.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SenderKeyRecord = void 0;
+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);
+    }
+}
+exports.SenderKeyRecord = SenderKeyRecord;