@sgintokic/baileys 0.0.2

package/lib/Utils/noise-handler.js

@@ -0,0 +1,229 @@
+import { Boom } from "@hapi/boom";
+import { proto } from "../../WAProto/index.js";
+import { NOISE_MODE, WA_CERT_DETAILS } from "../Defaults/index.js";
+import { decodeBinaryNode } from "../WABinary/index.js";
+import { aesDecryptGCM, aesEncryptGCM, Curve, hkdf, sha256 } from "./crypto.js";
+const IV_LENGTH = 12;
+const EMPTY_BUFFER = Buffer.alloc(0);
+const generateIV = (counter) => {
+  const iv = new ArrayBuffer(IV_LENGTH);
+  new DataView(iv).setUint32(8, counter);
+  return new Uint8Array(iv);
+};
+class TransportState {
+  constructor(encKey, decKey) {
+    this.encKey = encKey;
+    this.decKey = decKey;
+    this.readCounter = 0;
+    this.writeCounter = 0;
+    this.iv = new Uint8Array(IV_LENGTH);
+  }
+  encrypt(plaintext) {
+    const c = this.writeCounter++;
+    this.iv[8] = (c >>> 24) & 255;
+    this.iv[9] = (c >>> 16) & 255;
+    this.iv[10] = (c >>> 8) & 255;
+    this.iv[11] = c & 255;
+    return aesEncryptGCM(plaintext, this.encKey, this.iv, EMPTY_BUFFER);
+  }
+  decrypt(ciphertext) {
+    const c = this.readCounter++;
+    this.iv[8] = (c >>> 24) & 255;
+    this.iv[9] = (c >>> 16) & 255;
+    this.iv[10] = (c >>> 8) & 255;
+    this.iv[11] = c & 255;
+    return aesDecryptGCM(ciphertext, this.decKey, this.iv, EMPTY_BUFFER);
+  }
+}
+export const makeNoiseHandler = ({
+  keyPair: { private: privateKey, public: publicKey },
+  NOISE_HEADER,
+  logger,
+  routingInfo,
+}) => {
+  logger = logger.child({ class: "ns" });
+  const data = Buffer.from(NOISE_MODE);
+  let hash = data.byteLength === 32 ? data : sha256(data);
+  let salt = hash;
+  let encKey = hash;
+  let decKey = hash;
+  let counter = 0;
+  let sentIntro = false;
+  let inBytes = Buffer.alloc(0);
+  let transport = null;
+  let isWaitingForTransport = false;
+  let pendingOnFrame = null;
+  let introHeader;
+  if (routingInfo) {
+    introHeader = Buffer.alloc(
+      7 + routingInfo.byteLength + NOISE_HEADER.length,
+    );
+    introHeader.write("ED", 0, "utf8");
+    introHeader.writeUint8(0, 2);
+    introHeader.writeUint8(1, 3);
+    introHeader.writeUint8(routingInfo.byteLength >> 16, 4);
+    introHeader.writeUint16BE(routingInfo.byteLength & 65535, 5);
+    introHeader.set(routingInfo, 7);
+    introHeader.set(NOISE_HEADER, 7 + routingInfo.byteLength);
+  } else {
+    introHeader = Buffer.from(NOISE_HEADER);
+  }
+  const authenticate = (data) => {
+    if (!transport) {
+      hash = sha256(Buffer.concat([hash, data]));
+    }
+  };
+  const encrypt = (plaintext) => {
+    if (transport) {
+      return transport.encrypt(plaintext);
+    }
+    const result = aesEncryptGCM(
+      plaintext,
+      encKey,
+      generateIV(counter++),
+      hash,
+    );
+    authenticate(result);
+    return result;
+  };
+  const decrypt = (ciphertext) => {
+    if (transport) {
+      return transport.decrypt(ciphertext);
+    }
+    const result = aesDecryptGCM(
+      ciphertext,
+      decKey,
+      generateIV(counter++),
+      hash,
+    );
+    authenticate(ciphertext);
+    return result;
+  };
+  const localHKDF = (data) => {
+    const key = hkdf(Buffer.from(data), 64, { salt: salt, info: "" });
+    return [key.subarray(0, 32), key.subarray(32)];
+  };
+  const mixIntoKey = (data) => {
+    const [write, read] = localHKDF(data);
+    salt = write;
+    encKey = read;
+    decKey = read;
+    counter = 0;
+  };
+  const finishInit = async () => {
+    isWaitingForTransport = true;
+    const [write, read] = localHKDF(new Uint8Array(0));
+    transport = new TransportState(write, read);
+    isWaitingForTransport = false;
+    logger.trace("Noise handler transitioned to Transport state");
+    if (pendingOnFrame) {
+      logger.trace(
+        { length: inBytes.length },
+        "Flushing buffered frames after transport ready",
+      );
+      await processData(pendingOnFrame);
+      pendingOnFrame = null;
+    }
+  };
+  const processData = async (onFrame) => {
+    let size;
+    while (true) {
+      if (inBytes.length < 3) return;
+      size = (inBytes[0] << 16) | (inBytes[1] << 8) | inBytes[2];
+      if (inBytes.length < size + 3) return;
+      let frame = inBytes.subarray(3, size + 3);
+      inBytes = inBytes.subarray(size + 3);
+      if (transport) {
+        const result = transport.decrypt(frame);
+        frame = await decodeBinaryNode(result);
+      }
+      if (logger.level === "trace") {
+        logger.trace({ msg: frame?.attrs?.id }, "recv frame");
+      }
+      onFrame(frame);
+    }
+  };
+  authenticate(NOISE_HEADER);
+  authenticate(publicKey);
+  return {
+    encrypt: encrypt,
+    decrypt: decrypt,
+    authenticate: authenticate,
+    mixIntoKey: mixIntoKey,
+    finishInit: finishInit,
+    processHandshake: ({ serverHello }, noiseKey) => {
+      authenticate(serverHello.ephemeral);
+      mixIntoKey(Curve.sharedKey(privateKey, serverHello.ephemeral));
+      const decStaticContent = decrypt(serverHello.static);
+      mixIntoKey(Curve.sharedKey(privateKey, decStaticContent));
+      const certDecoded = decrypt(serverHello.payload);
+      const { intermediate: certIntermediate, leaf } =
+        proto.CertChain.decode(certDecoded);
+      // leaf
+      if (!leaf?.details || !leaf?.signature) {
+        throw new Boom("invalid noise leaf certificate", { statusCode: 400 });
+      }
+      if (!certIntermediate?.details || !certIntermediate?.signature) {
+        throw new Boom("invalid noise intermediate certificate", {
+          statusCode: 400,
+        });
+      }
+      const details = proto.CertChain.NoiseCertificate.Details.decode(
+        certIntermediate.details,
+      );
+      const { issuerSerial } = details;
+      const verify = Curve.verify(details.key, leaf.details, leaf.signature);
+      const verifyIntermediate = Curve.verify(
+        WA_CERT_DETAILS.PUBLIC_KEY,
+        certIntermediate.details,
+        certIntermediate.signature,
+      );
+      if (!verify) {
+        throw new Boom("noise certificate signature invalid", {
+          statusCode: 400,
+        });
+      }
+      if (!verifyIntermediate) {
+        throw new Boom("noise intermediate certificate signature invalid", {
+          statusCode: 400,
+        });
+      }
+      if (issuerSerial !== WA_CERT_DETAILS.SERIAL) {
+        throw new Boom("certification match failed", { statusCode: 400 });
+      }
+      const keyEnc = encrypt(noiseKey.public);
+      mixIntoKey(Curve.sharedKey(noiseKey.private, serverHello.ephemeral));
+      return keyEnc;
+    },
+    encodeFrame: (data) => {
+      if (transport) {
+        data = transport.encrypt(data);
+      }
+      const dataLen = data.byteLength;
+      const introSize = sentIntro ? 0 : introHeader.length;
+      const frame = Buffer.allocUnsafe(introSize + 3 + dataLen);
+      if (!sentIntro) {
+        frame.set(introHeader);
+        sentIntro = true;
+      }
+      frame[introSize] = (dataLen >>> 16) & 255;
+      frame[introSize + 1] = (dataLen >>> 8) & 255;
+      frame[introSize + 2] = dataLen & 255;
+      frame.set(data, introSize + 3);
+      return frame;
+    },
+    decodeFrame: async (newData, onFrame) => {
+      if (isWaitingForTransport) {
+        inBytes = Buffer.concat([inBytes, newData]);
+        pendingOnFrame = onFrame;
+        return;
+      }
+      if (inBytes.length === 0) {
+        inBytes = Buffer.from(newData);
+      } else {
+        inBytes = Buffer.concat([inBytes, newData]);
+      }
+      await processData(onFrame);
+    },
+  };
+};

package/lib/Utils/offline-node-processor.js

@@ -0,0 +1,50 @@
+/**
+ * Creates a processor for offline stanza nodes that:
+ * - Queues nodes for sequential processing
+ * - Yields to the event loop periodically to avoid blocking
+ * - Catches handler errors to prevent the processing loop from crashing
+ */
+export function makeOfflineNodeProcessor(
+  nodeProcessorMap,
+  deps,
+  batchSize = 10,
+) {
+  const nodes = [];
+  let isProcessing = false;
+  const enqueue = (type, node) => {
+    nodes.push({ type: type, node: node });
+    if (isProcessing) {
+      return;
+    }
+    isProcessing = true;
+    const promise = async () => {
+      let processedInBatch = 0;
+      while (nodes.length && deps.isWsOpen()) {
+        const { type, node } = nodes.shift();
+        const nodeProcessor = nodeProcessorMap.get(type);
+        if (!nodeProcessor) {
+          deps.onUnexpectedError(
+            new Error(`unknown offline node type: ${type}`),
+            "processing offline node",
+          );
+          continue;
+        }
+        await nodeProcessor(node).catch((err) =>
+          deps.onUnexpectedError(err, `processing offline ${type}`),
+        );
+        processedInBatch++;
+        // Yield to event loop after processing a batch
+        // This prevents blocking the event loop for too long when there are many offline nodes
+        if (processedInBatch >= batchSize) {
+          processedInBatch = 0;
+          await deps.yieldToEventLoop();
+        }
+      }
+      isProcessing = false;
+    };
+    promise().catch((error) =>
+      deps.onUnexpectedError(error, "processing offline nodes"),
+    );
+  };
+  return { enqueue: enqueue };
+}

package/lib/Utils/pre-key-manager.js

@@ -0,0 +1,119 @@
+import PQueue from "p-queue";
+/**
+ * Manages pre-key operations with proper concurrency control
+ */ export class PreKeyManager {
+  constructor(store, logger) {
+    this.store = store;
+    this.logger = logger;
+    this.queues = new Map();
+  }
+  /**
+   * Get or create a queue for a specific key type
+   */ getQueue(keyType) {
+    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,
+    keyType,
+    transactionCache,
+    mutations,
+    isInTransaction,
+  ) {
+    const keyData = data[keyType];
+    if (!keyData) return;
+    return this.getQueue(keyType).add(async () => {
+      // Ensure structures exist
+      transactionCache[keyType] = transactionCache[keyType] || {};
+      mutations[keyType] = mutations[keyType] || {};
+      // Separate deletions from updates
+      const deletions = [];
+      const updates = {};
+      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
+   */ async processDeletions(
+    keyType,
+    ids,
+    transactionCache,
+    mutations,
+    isInTransaction,
+  ) {
+    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, keyType) {
+    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];
+        }
+      }
+    });
+  }
+}