@sixcore/baileys 1.0.0 → 1.0.1

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

@@ -1,95 +0,0 @@
-import { proto } from '../../../WAProto/index.js'
-import { CiphertextMessage } from './ciphertext-message'
-
-interface SenderKeyDistributionMessageStructure {
-	id: number
-	iteration: number
-	chainKey: string | Uint8Array
-	signingKey: string | Uint8Array
-}
-
-export class SenderKeyDistributionMessage extends CiphertextMessage {
-	private readonly id: number
-	private readonly iteration: number
-	private readonly chainKey: Uint8Array
-	private readonly signatureKey: Uint8Array
-	private readonly serialized: Uint8Array
-
-	constructor(
-		id?: number | null,
-		iteration?: number | null,
-		chainKey?: Uint8Array | null,
-		signatureKey?: Uint8Array | null,
-		serialized?: Uint8Array | null
-	) {
-		super()
-
-		if (serialized) {
-			try {
-				const message = serialized.slice(1)
-				const distributionMessage = proto.SenderKeyDistributionMessage.decode(
-					message
-				).toJSON() as SenderKeyDistributionMessageStructure
-
-				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 = proto.SenderKeyDistributionMessage.encode(
-				proto.SenderKeyDistributionMessage.create({
-					id,
-					iteration,
-					chainKey,
-					signingKey: this.signatureKey
-				})
-			).finish()
-
-			this.serialized = Buffer.concat([Buffer.from([version]), message])
-		}
-	}
-
-	private intsToByteHighAndLow(highValue: number, lowValue: number): number {
-		return (((highValue << 4) | lowValue) & 0xff) % 256
-	}
-
-	public serialize(): Uint8Array {
-		return this.serialized
-	}
-
-	public getType(): number {
-		return this.SENDERKEY_DISTRIBUTION_TYPE
-	}
-
-	public getIteration(): number {
-		return this.iteration
-	}
-
-	public getChainKey(): Uint8Array {
-		return this.chainKey
-	}
-
-	public getSignatureKey(): Uint8Array {
-		return this.signatureKey
-	}
-
-	public getId(): number {
-		return this.id
-	}
-}

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

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

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

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

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

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