@sixcore/baileys 1.0.0

package/src/Signal/Group/sender-key-message.ts

@@ -0,0 +1,96 @@
+import { calculateSignature, verifySignature } from 'libsignal/src/curve'
+import { proto } from '../../../WAProto/index.js'
+import { CiphertextMessage } from './ciphertext-message'
+
+interface SenderKeyMessageStructure {
+	id: number
+	iteration: number
+	ciphertext: string | Buffer
+}
+
+export class SenderKeyMessage extends CiphertextMessage {
+	private readonly SIGNATURE_LENGTH = 64
+	private readonly messageVersion: number
+	private readonly keyId: number
+	private readonly iteration: number
+	private readonly ciphertext: Uint8Array
+	private readonly signature: Uint8Array
+	private readonly serialized: Uint8Array
+
+	constructor(
+		keyId?: number | null,
+		iteration?: number | null,
+		ciphertext?: Uint8Array | null,
+		signatureKey?: Uint8Array | null,
+		serialized?: Uint8Array | 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 = proto.SenderKeyMessage.decode(message).toJSON() as SenderKeyMessageStructure
+
+			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 = 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
+		}
+	}
+
+	public getKeyId(): number {
+		return this.keyId
+	}
+
+	public getIteration(): number {
+		return this.iteration
+	}
+
+	public getCipherText(): Uint8Array {
+		return this.ciphertext
+	}
+
+	public verifySignature(signatureKey: Uint8Array): void {
+		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!')
+	}
+
+	private getSignature(signatureKey: Uint8Array, serialized: Uint8Array): Uint8Array {
+		return Buffer.from(calculateSignature(signatureKey, serialized))
+	}
+
+	public serialize(): Uint8Array {
+		return this.serialized
+	}
+
+	public getType(): number {
+		return 4
+	}
+}

package/src/Signal/Group/sender-key-name.ts

@@ -0,0 +1,66 @@
+interface Sender {
+	id: string
+	deviceId: number
+	toString(): string
+}
+
+function isNull(str: string | null): boolean {
+	return str === null || str === ''
+}
+
+function intValue(num: number): number {
+	const MAX_VALUE = 0x7fffffff
+	const MIN_VALUE = -0x80000000
+	if (num > MAX_VALUE || num < MIN_VALUE) {
+		return num & 0xffffffff
+	}
+
+	return num
+}
+
+function hashCode(strKey: string): number {
+	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
+}
+
+export class SenderKeyName {
+	private readonly groupId: string
+	private readonly sender: Sender
+
+	constructor(groupId: string, sender: Sender) {
+		this.groupId = groupId
+		this.sender = sender
+	}
+
+	public getGroupId(): string {
+		return this.groupId
+	}
+
+	public getSender(): Sender {
+		return this.sender
+	}
+
+	public serialize(): string {
+		return `${this.groupId}::${this.sender.id}::${this.sender.deviceId}`
+	}
+
+	public toString(): string {
+		return this.serialize()
+	}
+
+	public equals(other: SenderKeyName | null): boolean {
+		if (other === null) return false
+		return this.groupId === other.groupId && this.sender.toString() === other.sender.toString()
+	}
+
+	public hashCode(): number {
+		return hashCode(this.groupId) ^ hashCode(this.sender.toString())
+	}
+}

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

@@ -0,0 +1,69 @@
+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): SenderKeyRecord {
+		const str = Buffer.from(data).toString('utf-8')
+		const parsed = JSON.parse(str, BufferJSON.reviver)
+		return new SenderKeyRecord(parsed)
+	}
+}

package/src/Signal/Group/sender-key-state.ts

@@ -0,0 +1,134 @@
+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 class SenderKeyState {
+	private readonly MAX_MESSAGE_KEYS = 2000
+	private readonly senderKeyStateStructure: SenderKeyStateStructure
+
+	constructor(
+		id?: number | null,
+		iteration?: number | null,
+		chainKey?: Uint8Array | null | string,
+		signatureKeyPair?: { public: Uint8Array | string; private: Uint8Array | string } | null,
+		signatureKeyPublic?: Uint8Array | string | null,
+		signatureKeyPrivate?: Uint8Array | string | null,
+		senderKeyStateStructure?: SenderKeyStateStructure | null
+	) {
+		if (senderKeyStateStructure) {
+			this.senderKeyStateStructure = {
+				...senderKeyStateStructure,
+				senderMessageKeys: Array.isArray(senderKeyStateStructure.senderMessageKeys)
+					? senderKeyStateStructure.senderMessageKeys
+					: []
+			}
+		} else {
+			if (signatureKeyPair) {
+				signatureKeyPublic = signatureKeyPair.public
+				signatureKeyPrivate = signatureKeyPair.private
+			}
+
+			this.senderKeyStateStructure = {
+				senderKeyId: id || 0,
+				senderChainKey: {
+					iteration: iteration || 0,
+					seed: Buffer.from(chainKey || [])
+				},
+				senderSigningKey: {
+					public: Buffer.from(signatureKeyPublic || []),
+					private: Buffer.from(signatureKeyPrivate || [])
+				},
+				senderMessageKeys: []
+			}
+		}
+	}
+
+	public getKeyId(): number {
+		return this.senderKeyStateStructure.senderKeyId
+	}
+
+	public getSenderChainKey(): SenderChainKey {
+		return new SenderChainKey(
+			this.senderKeyStateStructure.senderChainKey.iteration,
+			this.senderKeyStateStructure.senderChainKey.seed
+		)
+	}
+
+	public setSenderChainKey(chainKey: SenderChainKey): void {
+		this.senderKeyStateStructure.senderChainKey = {
+			iteration: chainKey.getIteration(),
+			seed: chainKey.getSeed()
+		}
+	}
+
+	public getSigningKeyPublic(): Buffer {
+		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
+		}
+
+		return publicKey
+	}
+
+	public getSigningKeyPrivate(): Buffer | undefined {
+		const privateKey = this.senderKeyStateStructure.senderSigningKey.private
+
+		return Buffer.from(privateKey || [])
+	}
+
+	public hasSenderMessageKey(iteration: number): boolean {
+		return this.senderKeyStateStructure.senderMessageKeys.some(key => key.iteration === iteration)
+	}
+
+	public addSenderMessageKey(senderMessageKey: SenderMessageKey): void {
+		this.senderKeyStateStructure.senderMessageKeys.push({
+			iteration: senderMessageKey.getIteration(),
+			seed: senderMessageKey.getSeed()
+		})
+
+		if (this.senderKeyStateStructure.senderMessageKeys.length > this.MAX_MESSAGE_KEYS) {
+			this.senderKeyStateStructure.senderMessageKeys.shift()
+		}
+	}
+
+	public removeSenderMessageKey(iteration: number): SenderMessageKey | null {
+		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 SenderMessageKey(messageKey.iteration, messageKey.seed)
+		}
+
+		return null
+	}
+
+	public getStructure(): SenderKeyStateStructure {
+		return this.senderKeyStateStructure
+	}
+}

package/src/Signal/Group/sender-message-key.ts

@@ -0,0 +1,36 @@
+import { deriveSecrets } from 'libsignal/src/crypto'
+
+export class SenderMessageKey {
+	private readonly iteration: number
+	private readonly iv: Uint8Array
+	private readonly cipherKey: Uint8Array
+	private readonly seed: Uint8Array
+
+	constructor(iteration: number, seed: Uint8Array) {
+		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
+	}
+
+	public getIteration(): number {
+		return this.iteration
+	}
+
+	public getIv(): Uint8Array {
+		return this.iv
+	}
+
+	public getCipherKey(): Uint8Array {
+		return this.cipherKey
+	}
+
+	public getSeed(): Uint8Array {
+		return this.seed
+	}
+}