@sixcore/baileys 1.0.0

package/src/Utils/noise-handler.ts

@@ -0,0 +1,192 @@
+import { Boom } from '@hapi/boom'
+import { proto } from '../../WAProto/index.js'
+import { NOISE_MODE, WA_CERT_DETAILS } from '../Defaults'
+import type { KeyPair } from '../Types'
+import type { BinaryNode } from '../WABinary'
+import { decodeBinaryNode } from '../WABinary'
+import { aesDecryptGCM, aesEncryptGCM, Curve, hkdf, sha256 } from './crypto'
+import type { ILogger } from './logger'
+
+const generateIV = (counter: number) => {
+	const iv = new ArrayBuffer(12)
+	new DataView(iv).setUint32(8, counter)
+
+	return new Uint8Array(iv)
+}
+
+export const makeNoiseHandler = ({
+	keyPair: { private: privateKey, public: publicKey },
+	NOISE_HEADER,
+	logger,
+	routingInfo
+}: {
+	keyPair: KeyPair
+	NOISE_HEADER: Uint8Array
+	logger: ILogger
+	routingInfo?: Buffer | undefined
+}) => {
+	logger = logger.child({ class: 'ns' })
+
+	const authenticate = (data: Uint8Array) => {
+		if (!isFinished) {
+			hash = sha256(Buffer.concat([hash, data]))
+		}
+	}
+
+	const encrypt = (plaintext: Uint8Array) => {
+		const result = aesEncryptGCM(plaintext, encKey, generateIV(writeCounter), hash)
+
+		writeCounter += 1
+
+		authenticate(result)
+		return result
+	}
+
+	const decrypt = (ciphertext: Uint8Array) => {
+		// before the handshake is finished, we use the same counter
+		// after handshake, the counters are different
+		const iv = generateIV(isFinished ? readCounter : writeCounter)
+		const result = aesDecryptGCM(ciphertext, decKey, iv, hash)
+
+		if (isFinished) {
+			readCounter += 1
+		} else {
+			writeCounter += 1
+		}
+
+		authenticate(ciphertext)
+		return result
+	}
+
+	const localHKDF = async (data: Uint8Array) => {
+		const key = await hkdf(Buffer.from(data), 64, { salt, info: '' })
+		return [key.slice(0, 32), key.slice(32)]
+	}
+
+	const mixIntoKey = async (data: Uint8Array) => {
+		const [write, read] = await localHKDF(data)
+		salt = write!
+		encKey = read!
+		decKey = read!
+		readCounter = 0
+		writeCounter = 0
+	}
+
+	const finishInit = async () => {
+		const [write, read] = await localHKDF(new Uint8Array(0))
+		encKey = write!
+		decKey = read!
+		hash = Buffer.from([])
+		readCounter = 0
+		writeCounter = 0
+		isFinished = true
+	}
+
+	const data = Buffer.from(NOISE_MODE)
+	let hash = data.byteLength === 32 ? data : sha256(data)
+	let salt = hash
+	let encKey = hash
+	let decKey = hash
+	let readCounter = 0
+	let writeCounter = 0
+	let isFinished = false
+	let sentIntro = false
+
+	let inBytes = Buffer.alloc(0)
+
+	authenticate(NOISE_HEADER)
+	authenticate(publicKey)
+
+	return {
+		encrypt,
+		decrypt,
+		authenticate,
+		mixIntoKey,
+		finishInit,
+		processHandshake: async ({ serverHello }: proto.HandshakeMessage, noiseKey: KeyPair) => {
+			authenticate(serverHello!.ephemeral!)
+			await mixIntoKey(Curve.sharedKey(privateKey, serverHello!.ephemeral!))
+
+			const decStaticContent = decrypt(serverHello!.static!)
+			await mixIntoKey(Curve.sharedKey(privateKey, decStaticContent))
+
+			const certDecoded = decrypt(serverHello!.payload!)
+
+			const { intermediate: certIntermediate /*leaf*/ } = proto.CertChain.decode(certDecoded)
+			// TODO: handle this leaf stuff
+			const { issuerSerial } = proto.CertChain.NoiseCertificate.Details.decode(certIntermediate!.details!)
+
+			if (issuerSerial !== WA_CERT_DETAILS.SERIAL) {
+				throw new Boom('certification match failed', { statusCode: 400 })
+			}
+
+			const keyEnc = encrypt(noiseKey.public)
+			await mixIntoKey(Curve.sharedKey(noiseKey.private, serverHello!.ephemeral!))
+
+			return keyEnc
+		},
+		encodeFrame: (data: Buffer | Uint8Array) => {
+			if (isFinished) {
+				data = encrypt(data)
+			}
+
+			let header: Buffer
+
+			if (routingInfo) {
+				header = Buffer.alloc(7)
+				header.write('ED', 0, 'utf8')
+				header.writeUint8(0, 2)
+				header.writeUint8(1, 3)
+				header.writeUint8(routingInfo.byteLength >> 16, 4)
+				header.writeUint16BE(routingInfo.byteLength & 65535, 5)
+				header = Buffer.concat([header, routingInfo, NOISE_HEADER])
+			} else {
+				header = Buffer.from(NOISE_HEADER)
+			}
+
+			const introSize = sentIntro ? 0 : header.length
+			const frame = Buffer.alloc(introSize + 3 + data.byteLength)
+
+			if (!sentIntro) {
+				frame.set(header)
+				sentIntro = true
+			}
+
+			frame.writeUInt8(data.byteLength >> 16, introSize)
+			frame.writeUInt16BE(65535 & data.byteLength, introSize + 1)
+			frame.set(data, introSize + 3)
+
+			return frame
+		},
+		decodeFrame: async (newData: Buffer | Uint8Array, onFrame: (buff: Uint8Array | BinaryNode) => void) => {
+			// the binary protocol uses its own framing mechanism
+			// on top of the WS frames
+			// so we get this data and separate out the frames
+			const getBytesSize = () => {
+				if (inBytes.length >= 3) {
+					return (inBytes.readUInt8() << 16) | inBytes.readUInt16BE(1)
+				}
+			}
+
+			inBytes = Buffer.concat([inBytes, newData])
+
+			logger.trace(`recv ${newData.length} bytes, total recv ${inBytes.length} bytes`)
+
+			let size = getBytesSize()
+			while (size && inBytes.length >= size + 3) {
+				let frame: Uint8Array | BinaryNode = inBytes.slice(3, size + 3)
+				inBytes = inBytes.slice(size + 3)
+
+				if (isFinished) {
+					const result = decrypt(frame)
+					frame = await decodeBinaryNode(result)
+				}
+
+				logger.trace({ msg: (frame as BinaryNode)?.attrs?.id }, 'recv frame')
+
+				onFrame(frame)
+				size = getBytesSize()
+			}
+		}
+	}
+}

package/src/Utils/pre-key-manager.ts

@@ -0,0 +1,126 @@
+import PQueue from 'p-queue'
+import type { SignalDataSet, SignalDataTypeMap, SignalKeyStore } from '../Types'
+import type { ILogger } from './logger'
+
+/**
+ * Manages pre-key operations with proper concurrency control
+ */
+export class PreKeyManager {
+	private readonly queues = new Map<string, PQueue>()
+
+	constructor(
+		private readonly store: SignalKeyStore,
+		private readonly logger: ILogger
+	) {}
+
+	/**
+	 * Get or create a queue for a specific key type
+	 */
+	private getQueue(keyType: string): PQueue {
+		if (!this.queues.has(keyType)) {
+			this.queues.set(keyType, new PQueue({ concurrency: 1 }))
+		}
+
+		return this.queues.get(keyType)!
+	}
+
+	/**
+	 * Process pre-key operations (updates and deletions)
+	 */
+	async processOperations(
+		data: SignalDataSet,
+		keyType: keyof SignalDataTypeMap,
+		transactionCache: SignalDataSet,
+		mutations: SignalDataSet,
+		isInTransaction: boolean
+	): Promise<void> {
+		const keyData = data[keyType]
+		if (!keyData) return
+
+		return this.getQueue(keyType).add(async () => {
+			// Ensure structures exist
+			transactionCache[keyType] = transactionCache[keyType] || ({} as any)
+			mutations[keyType] = mutations[keyType] || ({} as any)
+
+			// Separate deletions from updates
+			const deletions: string[] = []
+			const updates: Record<string, any> = {}
+
+			for (const keyId in keyData) {
+				if (keyData[keyId] === null) {
+					deletions.push(keyId)
+				} else {
+					updates[keyId] = keyData[keyId]
+				}
+			}
+
+			// Process updates (no validation needed)
+			if (Object.keys(updates).length > 0) {
+				Object.assign(transactionCache[keyType]!, updates)
+				Object.assign(mutations[keyType]!, updates)
+			}
+
+			// Process deletions with validation
+			if (deletions.length > 0) {
+				await this.processDeletions(keyType, deletions, transactionCache, mutations, isInTransaction)
+			}
+		})
+	}
+
+	/**
+	 * Process deletions with validation
+	 */
+	private async processDeletions(
+		keyType: keyof SignalDataTypeMap,
+		ids: string[],
+		transactionCache: SignalDataSet,
+		mutations: SignalDataSet,
+		isInTransaction: boolean
+	): Promise<void> {
+		if (isInTransaction) {
+			// In transaction, only allow deletion if key exists in cache
+			for (const keyId of ids) {
+				if (transactionCache[keyType]?.[keyId]) {
+					transactionCache[keyType][keyId] = null
+					mutations[keyType]![keyId] = null
+				} else {
+					this.logger.warn(`Skipping deletion of non-existent ${keyType} in transaction: ${keyId}`)
+				}
+			}
+		} else {
+			// Outside transaction, validate against store
+			const existingKeys = await this.store.get(keyType, ids)
+			for (const keyId of ids) {
+				if (existingKeys[keyId]) {
+					transactionCache[keyType]![keyId] = null
+					mutations[keyType]![keyId] = null
+				} else {
+					this.logger.warn(`Skipping deletion of non-existent ${keyType}: ${keyId}`)
+				}
+			}
+		}
+	}
+
+	/**
+	 * Validate and process pre-key deletions outside transactions
+	 */
+	async validateDeletions(data: SignalDataSet, keyType: keyof SignalDataTypeMap): Promise<void> {
+		const keyData = data[keyType]
+		if (!keyData) return
+
+		return this.getQueue(keyType).add(async () => {
+			// Find all deletion requests
+			const deletionIds = Object.keys(keyData).filter(id => keyData[id] === null)
+			if (deletionIds.length === 0) return
+
+			// Validate deletions
+			const existingKeys = await this.store.get(keyType, deletionIds)
+			for (const keyId of deletionIds) {
+				if (!existingKeys[keyId]) {
+					this.logger.warn(`Skipping deletion of non-existent ${keyType}: ${keyId}`)
+					delete data[keyType]![keyId]
+				}
+			}
+		})
+	}
+}