dcodeindra-baileyspro 2.3.9

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

@@ -0,0 +1,77 @@
+import { BufferJSON } from '../../Utils/generics'
+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 class SenderKeyRecord {
+	private readonly MAX_STATES = 5
+	private readonly senderKeyStates: SenderKeyState[] = []
+
+	constructor(serialized?: SenderKeyStateStructure[]) {
+		if (serialized) {
+			for (const structure of serialized) {
+				this.senderKeyStates.push(new SenderKeyState(null, null, null, null, null, null, structure))
+			}
+		}
+	}
+
+	public isEmpty(): boolean {
+		return this.senderKeyStates.length === 0
+	}
+
+	public getSenderKeyState(keyId?: number): SenderKeyState | undefined {
+		if (keyId === undefined && this.senderKeyStates.length) {
+			return this.senderKeyStates[this.senderKeyStates.length - 1]
+		}
+
+		return this.senderKeyStates.find(state => state.getKeyId() === keyId)
+	}
+
+	public addSenderKeyState(id: number, iteration: number, chainKey: Uint8Array, signatureKey: Uint8Array): void {
+		this.senderKeyStates.push(new SenderKeyState(id, iteration, chainKey, null, signatureKey))
+		if (this.senderKeyStates.length > this.MAX_STATES) {
+			this.senderKeyStates.shift()
+		}
+	}
+
+	public setSenderKeyState(
+		id: number,
+		iteration: number,
+		chainKey: Uint8Array,
+		keyPair: { public: Uint8Array; private: Uint8Array }
+	): void {
+		this.senderKeyStates.length = 0
+		this.senderKeyStates.push(new SenderKeyState(id, iteration, chainKey, keyPair))
+	}
+
+	public serialize(): SenderKeyStateStructure[] {
+		return this.senderKeyStates.map(state => state.getStructure())
+	}
+	static deserialize(data: Uint8Array | string | SenderKeyStateStructure[]): SenderKeyRecord {
+		let parsed: SenderKeyStateStructure[]
+		if (typeof data === 'string') {
+			parsed = JSON.parse(data, BufferJSON.reviver)
+		} else if (data instanceof Uint8Array) {
+			const str = Buffer.from(data).toString('utf-8')
+			parsed = JSON.parse(str, BufferJSON.reviver)
+		} else {
+			parsed = data
+		}
+
+		return new SenderKeyRecord(parsed)
+	}
+}

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

@@ -0,0 +1,104 @@
+"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
+        if (senderKeyStateStructure) {
+            this.senderKeyStateStructure = senderKeyStateStructure
+        }
+        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 || Buffer.alloc(0)
+            }
+            const signingKeyStructure = {
+                public: typeof signatureKeyPublic === 'string'
+                    ? Buffer.from(signatureKeyPublic, 'base64')
+                    : signatureKeyPublic || Buffer.alloc(0)
+            }
+            if (signatureKeyPrivate) {
+                signingKeyStructure.private =
+                    typeof signatureKeyPrivate === 'string' ? Buffer.from(signatureKeyPrivate, 'base64') : signatureKeyPrivate
+            }
+            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() {
+        const publicKey = this.senderKeyStateStructure.senderSigningKey.public
+        if (publicKey instanceof Buffer) {
+            return publicKey
+        }
+        else if (typeof publicKey === 'string') {
+            return Buffer.from(publicKey, 'base64')
+        }
+        return Buffer.from(publicKey || [])
+    }
+    getSigningKeyPrivate() {
+        const privateKey = this.senderKeyStateStructure.senderSigningKey.private
+        if (!privateKey) {
+            return undefined
+        }
+        if (privateKey instanceof Buffer) {
+            return privateKey
+        }
+        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/Group/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/Group/sender-message-key.js

@@ -0,0 +1,33 @@
+"use strict"
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const crypto_1 = require("@itsukichan/libsignal-node/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/libsignal.d.ts

@@ -0,0 +1,3 @@
+import { SignalAuthState } from '../Types'
+import { SignalRepository } from '../Types/Signal'
+export declare function makeLibSignalRepository(auth: SignalAuthState): SignalRepository

package/lib/Signal/libsignal.js

@@ -0,0 +1,153 @@
+"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 (mod) {
+if (mod && mod.__esModule) return mod
+var result = {}
+if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k)
+__setModuleDefault(result, mod)
+return result
+}
+Object.defineProperty(exports, "__esModule", { value: true })
+const libsignal = __importStar(require("libsignal"))
+const WASignalGroup_1 = require("../../WASignalGroup")
+const Utils_1 = require("../Utils")
+const WABinary_1 = require("../WABinary")
+function makeLibSignalRepository(auth) {
+const storage = signalStorage(auth)
+return {
+decryptGroupMessage({ group, authorJid, msg }) {
+const senderName = jidToSignalSenderKeyName(group, authorJid)
+const cipher = new WASignalGroup_1.GroupCipher(storage, senderName)
+return cipher.decrypt(msg)
+},
+async processSenderKeyDistributionMessage({ item, authorJid }) {
+const builder = new WASignalGroup_1.GroupSessionBuilder(storage)
+const senderName = jidToSignalSenderKeyName(item.groupId, authorJid)
+const senderMsg = new WASignalGroup_1.SenderKeyDistributionMessage(null, null, null, null, item.axolotlSenderKeyDistributionMessage)
+const { [senderName]: senderKey } = await auth.keys.get('sender-key', [senderName])
+if (!senderKey) {
+await storage.storeSenderKey(senderName, new WASignalGroup_1.SenderKeyRecord())
+}
+await builder.process(senderName, senderMsg)
+},
+async decryptMessage({ jid, type, ciphertext }) {
+const addr = jidToSignalProtocolAddress(jid)
+const session = new libsignal.SessionCipher(storage, addr)
+let result
+switch (type) {
+case 'pkmsg':
+result = await session.decryptPreKeyWhisperMessage(ciphertext)
+break
+case 'msg':
+result = await session.decryptWhisperMessage(ciphertext)
+break
+}
+return result
+},
+async encryptMessage({ jid, data }) {
+const addr = jidToSignalProtocolAddress(jid)
+const cipher = new libsignal.SessionCipher(storage, addr)
+const { type: sigType, body } = await cipher.encrypt(data)
+const type = sigType === 3 ? 'pkmsg' : 'msg'
+return { type, ciphertext: Buffer.from(body, 'binary') }
+},
+async encryptGroupMessage({ group, meId, data }) {
+const senderName = jidToSignalSenderKeyName(group, meId)
+const builder = new WASignalGroup_1.GroupSessionBuilder(storage)
+const { [senderName]: senderKey } = await auth.keys.get('sender-key', [senderName])
+if (!senderKey) {
+await storage.storeSenderKey(senderName, new WASignalGroup_1.SenderKeyRecord())
+}
+const senderKeyDistributionMessage = await builder.create(senderName)
+const session = new WASignalGroup_1.GroupCipher(storage, senderName)
+const ciphertext = await session.encrypt(data)
+return {
+ciphertext,
+senderKeyDistributionMessage: senderKeyDistributionMessage.serialize(),
+}
+},
+async injectE2ESession({ jid, session }) {
+const cipher = new libsignal.SessionBuilder(storage, jidToSignalProtocolAddress(jid))
+await cipher.initOutgoing(session)
+},
+jidToSignalProtocolAddress(jid) {
+return jidToSignalProtocolAddress(jid).toString()
+},
+}
+}
+const jidToSignalProtocolAddress = (jid) => {
+const { user, device } = WABinary_1.jidDecode(jid)
+return new libsignal.ProtocolAddress(user, device || 0)
+}
+const jidToSignalSenderKeyName = (group, user) => {
+return new WASignalGroup_1.SenderKeyName(group, jidToSignalProtocolAddress(user)).toString()
+}
+function signalStorage({ creds, keys }) {
+return {
+loadSession: async (id) => {
+const { [id]: sess } = await keys.get('session', [id])
+if (sess) {
+return libsignal.SessionRecord.deserialize(sess)
+}
+},
+storeSession: async (id, session) => {
+await keys.set({ 'session': { [id]: session.serialize() } })
+},
+isTrustedIdentity: () => {
+return true
+},
+loadPreKey: async (id) => {
+const keyId = id.toString()
+const { [keyId]: key } = await keys.get('pre-key', [keyId])
+if (key) {
+return {
+privKey: Buffer.from(key.private),
+pubKey: Buffer.from(key.public)
+}
+}
+},
+removePreKey: (id) => keys.set({ 'pre-key': { [id]: null } }),
+loadSignedPreKey: () => {
+const key = creds.signedPreKey
+return {
+privKey: Buffer.from(key.keyPair.private),
+pubKey: Buffer.from(key.keyPair.public)
+}
+},
+loadSenderKey: async (keyId) => {
+const { [keyId]: key } = await keys.get('sender-key', [keyId])
+if (key) {
+return new WASignalGroup_1.SenderKeyRecord(key)
+}
+},
+storeSenderKey: async (keyId, key) => {
+await keys.set({ 'sender-key': { [keyId]: key.serialize() } })
+},
+getOurRegistrationId: () => (creds.registrationId),
+getOurIdentity: () => {
+const { signedIdentityKey } = creds
+return {
+privKey: Buffer.from(signedIdentityKey.private),
+pubKey: Utils_1.generateSignalPubKey(signedIdentityKey.public),
+}
+}
+}
+}
+module.exports = {
+makeLibSignalRepository
+}

package/lib/Socket/Client/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types'
+export * from './websocket'

package/lib/Socket/Client/index.js

@@ -0,0 +1,18 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p)
+}
+Object.defineProperty(exports, "__esModule", { value: true })
+__exportStar(require("./types"), exports)
+__exportStar(require("./websocket"), exports)

package/lib/Socket/Client/types.d.ts

@@ -0,0 +1,15 @@
+import { EventEmitter } from 'events'
+import { URL } from 'url'
+import { SocketConfig } from '../../Types'
+export declare abstract class AbstractSocketClient extends EventEmitter {
+url: URL
+config: SocketConfig
+abstract get isOpen(): boolean
+abstract get isClosed(): boolean
+abstract get isClosing(): boolean
+abstract get isConnecting(): boolean
+constructor(url: URL, config: SocketConfig)
+abstract connect(): Promise<void>
+abstract close(): Promise<void>
+abstract send(str: Uint8Array | string, cb?: (err?: Error) => void): boolean
+}

package/lib/Socket/Client/types.js

@@ -0,0 +1,14 @@
+"use strict"
+Object.defineProperty(exports, "__esModule", { value: true })
+const events_1 = require("events")
+class AbstractSocketClient extends events_1.EventEmitter {
+constructor(url, config) {
+super()
+this.url = url
+this.config = config
+this.setMaxListeners(0)
+}
+}
+module.exports = {
+AbstractSocketClient
+}

package/lib/Socket/Client/websocket.d.ts

@@ -0,0 +1,12 @@
+import WebSocket from 'ws'
+import { AbstractSocketClient } from './types'
+export declare class WebSocketClient extends AbstractSocketClient {
+protected socket: WebSocket | null
+get isOpen(): boolean
+get isClosed(): boolean
+get isClosing(): boolean
+get isConnecting(): boolean
+connect(): Promise<void>
+close(): Promise<void>
+send(str: string | Uint8Array, cb?: (err?: Error) => void): boolean
+}

package/lib/Socket/Client/websocket.js

@@ -0,0 +1,57 @@
+"use strict"
+var __importDefault = (this && this.__importDefault) || function (mod) {
+return (mod && mod.__esModule) ? mod : { "default": mod }
+}
+Object.defineProperty(exports, "__esModule", { value: true })
+const ws_1 = __importDefault(require("ws"))
+const Defaults_1 = require("../../Defaults")
+const types_1 = require("./types")
+class WebSocketClient extends types_1.AbstractSocketClient {
+constructor() {
+super(...arguments)
+this.socket = null
+}
+get isOpen() {
+return this.socket?.readyState === ws_1.default.OPEN
+}
+get isClosed() {
+return this.socket?.readyState === ws_1.default.CLOSED
+}
+get isClosing() {
+this.socket?.readyState === ws_1.default.CLOSING
+}
+get isConnecting() {
+this.socket?.readyState === ws_1.default.CONNECTING
+}
+async connect() {
+if (this.socket) {
+return
+}
+this.socket = new ws_1.default(this.url, {
+origin: Defaults_1.DEFAULT_ORIGIN,
+headers: this.config.options?.headers,
+handshakeTimeout: this.config.connectTimeoutMs,
+timeout: this.config.connectTimeoutMs,
+agent: this.config.agent,
+})
+this.socket.setMaxListeners(0)
+const events = ['close', 'error', 'upgrade', 'message', 'open', 'ping', 'pong', 'unexpected-response']
+for (const event of events) {
+this.socket?.on(event, (...args) => this.emit(event, ...args))
+}
+}
+async close() {
+if (!this.socket) {
+return
+}
+this.socket.close()
+this.socket = null
+}
+send(str, cb) {
+this.socket?.send(str, cb)
+return Boolean(this.socket)
+}
+}
+module.exports = {
+WebSocketClient
+}