@areumtecnologia/wasockets 2.0.0 → 2.3.0

package/lib/Utils/messages-media.js

@@ -17,11 +17,17 @@ const {
   createReadStream, 
   createWriteStream
 } = require("fs")
-const {
-  parseBuffer, 
-  parseFile, 
-  parseStream
-} = require('music-metadata')
+let _musicMetadata;
+const getMusicMetadata = async () => {
+    if (!_musicMetadata) {
+        try {
+            _musicMetadata = require('music-metadata');
+        } catch {
+            _musicMetadata = await import('music-metadata');
+        }
+    }
+    return _musicMetadata;
+};
 const { tmpdir } = require("os")
 const { join } = require("path")
 const {
@@ -175,21 +181,28 @@ const extractImageThumb = async (bufferOrFilePath, width = 32, quality = 50) =>
             }
         }
     }
-    else if ('jimp' in lib && typeof lib.jimp.read === 'function') {
-            const { read, MIME_JPEG, RESIZE_BEZIER, AUTO } = lib.jimp
-        const jimp = await read(bufferOrFilePath)
+    else if ('jimp' in lib && (typeof lib.jimp.read === 'function' || typeof lib.jimp.Jimp?.read === 'function')) {
+        const JimpClass = lib.jimp.Jimp || lib.jimp;
+        const jimp = await JimpClass.read(bufferOrFilePath);
         const dimensions = {
-            width: jimp.getWidth(),
-            height: jimp.getHeight() 
+            width: typeof jimp.getWidth === 'function' ? jimp.getWidth() : jimp.width,
+            height: typeof jimp.getHeight === 'function' ? jimp.getHeight() : jimp.height 
+        };
+        let buffer;
+        if (typeof jimp.getBufferAsync === 'function') {
+            const { MIME_JPEG, RESIZE_BEZIER, AUTO } = lib.jimp;
+            buffer = await jimp
+                .quality(quality) 
+                .resize(width, AUTO, RESIZE_BEZIER) 
+                .getBufferAsync(MIME_JPEG);
+        } else {
+            jimp.resize({ w: width });
+            buffer = await jimp.getBuffer(lib.jimp.JimpMime?.jpeg || 'image/jpeg', { quality });
         }
-        const buffer = await jimp
-         .quality(quality) 
-         .resize(width, AUTO, RESIZE_BEZIER) 
-         .getBufferAsync(MIME_JPEG) 
         return {
             buffer,
             original: dimensions
-        }
+        };
     }
     else {
         throw new Boom('No image processing library available')
@@ -227,11 +240,21 @@ const generateProfilePicture = async (mediaUpload, dimensions) => {
             quality: 50
         }).toBuffer()
     }
-    else if ('jimp' in lib && typeof lib.jimp?.read === 'function') {
-        const jimp = await lib.jimp.read(buffer)
-        const min = Math.min(jimp.width, jimp.height)
-        const cropped = jimp.crop({ x: 0, y: 0, w: min, h: min })
-        img = cropped.resize({ w, h, mode: lib.jimp.ResizeStrategy.BILINEAR }).getBuffer('image/jpeg', { quality: 50 })
+    else if ('jimp' in lib && (typeof lib.jimp?.read === 'function' || typeof lib.jimp?.Jimp?.read === 'function')) {
+        const JimpClass = lib.jimp.Jimp || lib.jimp;
+        const jimp = await JimpClass.read(buffer);
+        const imgWidth = typeof jimp.getWidth === 'function' ? jimp.getWidth() : jimp.width;
+        const imgHeight = typeof jimp.getHeight === 'function' ? jimp.getHeight() : jimp.height;
+        const min = Math.min(imgWidth, imgHeight);
+        const cropped = typeof jimp.crop === 'function' && jimp.crop.length > 1
+            ? jimp.crop(0, 0, min, min)
+            : jimp.crop({ x: 0, y: 0, w: min, h: min });
+        const mode = lib.jimp.ResizeStrategy?.BILINEAR || lib.jimp.RESIZE_BILINEAR;
+        if (typeof cropped.getBufferAsync === 'function') {
+            img = cropped.resize(w, h, mode).getBufferAsync(lib.jimp.MIME_JPEG);
+        } else {
+            img = cropped.resize({ w, h, mode }).getBuffer(lib.jimp.JimpMime?.jpeg || 'image/jpeg', { quality: 50 });
+        }
     }
     else {
         throw new Boom('No image processing library available');
@@ -251,7 +274,7 @@ async function getAudioDuration(buffer) {
     const options = {
             duration: true
     }
-
+    const { parseBuffer, parseFile, parseStream } = await getMusicMetadata();
     let metadata
 
     if (Buffer.isBuffer(buffer)) {

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

@@ -2,7 +2,22 @@
 
 Object.defineProperty(exports, "__esModule", { value: true })
 
-const { default: PQueue } = require("p-queue") 
+let PQueue
+try {
+    const pq = require("p-queue")
+    PQueue = pq.default || pq
+} catch {
+    PQueue = class SimpleQueue {
+        constructor() {
+            this._chain = Promise.resolve()
+        }
+        add(fn) {
+            const result = this._chain.then(() => fn())
+            this._chain = result.catch(() => {})
+            return result
+        }
+    }
+} 
 
 /**
  * Manages pre-key operations with proper concurrency control

package/lib/Utils/validate-connection.js

@@ -30,9 +30,9 @@ const getUserAgent = (config) => {
             secondary: config.version[1],
             tertiary: config.version[2],
         },
-        platform: /*config.browser[1].toLocaleLowerCase().includes('android') 
-                         ? proto.ClientPayload.UserAgent.Platform.ANDROID 
-                         :*/ proto.ClientPayload.UserAgent.Platform.WEB,
+        platform: config.browser?.[1]?.toLowerCase().includes('android')
+            ? proto.ClientPayload.UserAgent.Platform.ANDROID
+            : proto.ClientPayload.UserAgent.Platform.WEB,
         releaseChannel: proto.ClientPayload.UserAgent.ReleaseChannel.RELEASE,
         osVersion: config.browser?.[2] || '10.0.22631',
         device: 'Desktop',
@@ -46,7 +46,7 @@ const getUserAgent = (config) => {
 
 const PLATFORM_MAP = {
     'Mac OS': proto.ClientPayload.WebInfo.WebSubPlatform.DARWIN,
-    'Windows': proto.ClientPayload.WebInfo.WebSubPlatform.WIN32
+    'Windows': proto.ClientPayload.WebInfo.WebSubPlatform.WIN_HYBRID
 }
 
 const getWebInfo = (config) => {
@@ -66,10 +66,9 @@ const getClientPayload = (config) => {
         userAgent: getUserAgent(config),
     }
     
-    /*if (!config.browser[1].toLocaleLowerCase().includes('android')) { 
-   	 payload.webInfo = getWebInfo(config) 
-    }*/
-    payload.webInfo = getWebInfo(config) 
+    if (!config.browser?.[1]?.toLowerCase().includes('android')) { 
+        payload.webInfo = getWebInfo(config) 
+    }
     
     return payload
 }
@@ -91,9 +90,9 @@ const generateLoginNode = (userJid, config) => {
 const getPlatformType = (platform) => {
     const platformType = platform.toUpperCase()
     
-     /*if (platformType === 'ANDROID') { 
-     	return proto.DeviceProps.PlatformType.ANDROID_PHONE
-     }*/
+    if (platformType === 'ANDROID') { 
+        return proto.DeviceProps.PlatformType.ANDROID_PHONE
+    }
      
     return (proto.DeviceProps.PlatformType[platformType] ||
         proto.DeviceProps.PlatformType.CHROME)

package/lib/VoIP/VoIPCrypto.js

@@ -0,0 +1,150 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+
+const crypto = require("crypto");
+
+/**
+ * WhatsApp VoIP SRTP Key Derivation & Packet Protection
+ * Conforms to WhatsApp VoIP specifications (wacrg / AstraCalls / RFC 3711)
+ */
+
+const SRTP_LABEL = {
+    CALLER_AUDIO_KEY: "WhatsApp VoIP Master Key Caller Audio",
+    CALLER_AUDIO_SALT: "WhatsApp VoIP Master Salt Caller Audio",
+    CALLEE_AUDIO_KEY: "WhatsApp VoIP Master Key Callee Audio",
+    CALLEE_AUDIO_SALT: "WhatsApp VoIP Master Salt Callee Audio",
+    CALLER_VIDEO_KEY: "WhatsApp VoIP Master Key Caller Video",
+    CALLER_VIDEO_SALT: "WhatsApp VoIP Master Salt Caller Video",
+    CALLEE_VIDEO_KEY: "WhatsApp VoIP Master Key Callee Video",
+    CALLEE_VIDEO_SALT: "WhatsApp VoIP Master Salt Callee Video",
+};
+
+/**
+ * Standard HKDF extraction & expansion using SHA-256
+ */
+function hkdfDerive(ikm, salt, info, length) {
+    const actualSalt = salt && salt.length > 0 ? salt : Buffer.alloc(32, 0);
+    const prk = crypto.createHmac("sha256", actualSalt).update(ikm).digest();
+
+    let prev = Buffer.alloc(0);
+    const buffers = [];
+    let currentLen = 0;
+    let counter = 1;
+
+    while (currentLen < length) {
+        const hmac = crypto.createHmac("sha256", prk);
+        hmac.update(prev);
+        if (info) {
+            hmac.update(Buffer.isBuffer(info) ? info : Buffer.from(info, "utf8"));
+        }
+        hmac.update(Buffer.from([counter]));
+        prev = hmac.digest();
+        buffers.push(prev);
+        currentLen += prev.length;
+        counter++;
+    }
+
+    return Buffer.concat(buffers).subarray(0, length);
+}
+
+/**
+ * Derives all SRTP Master Keys and Salts from the 32-byte callKey
+ * @param {Buffer|Uint8Array} callKey 32-byte master call key negotiated via Signal
+ * @param {Buffer|Uint8Array} [salt] Optional salt (defaults to 32 zero bytes)
+ */
+function deriveVoIPKeys(callKey, salt = null) {
+    const keyBuf = Buffer.isBuffer(callKey) ? callKey : Buffer.from(callKey);
+    const saltBuf = salt ? (Buffer.isBuffer(salt) ? salt : Buffer.from(salt)) : Buffer.alloc(32, 0);
+
+    return {
+        // Caller (TX if caller, RX if callee)
+        callerAudio: {
+            masterKey: hkdfDerive(keyBuf, saltBuf, SRTP_LABEL.CALLER_AUDIO_KEY, 16),
+            masterSalt: hkdfDerive(keyBuf, saltBuf, SRTP_LABEL.CALLER_AUDIO_SALT, 14),
+        },
+        // Callee (RX if caller, TX if callee)
+        calleeAudio: {
+            masterKey: hkdfDerive(keyBuf, saltBuf, SRTP_LABEL.CALLEE_AUDIO_KEY, 16),
+            masterSalt: hkdfDerive(keyBuf, saltBuf, SRTP_LABEL.CALLEE_AUDIO_SALT, 14),
+        },
+        // Video Caller
+        callerVideo: {
+            masterKey: hkdfDerive(keyBuf, saltBuf, SRTP_LABEL.CALLER_VIDEO_KEY, 16),
+            masterSalt: hkdfDerive(keyBuf, saltBuf, SRTP_LABEL.CALLER_VIDEO_SALT, 14),
+        },
+        // Video Callee
+        calleeVideo: {
+            masterKey: hkdfDerive(keyBuf, saltBuf, SRTP_LABEL.CALLEE_VIDEO_KEY, 16),
+            masterSalt: hkdfDerive(keyBuf, saltBuf, SRTP_LABEL.CALLEE_VIDEO_SALT, 14),
+        },
+    };
+}
+
+/**
+ * Generates an SRTP Initialization Vector (IV) from SSRC, Sequence Number, and Master Salt
+ * Conforms to RFC 3711 Section 4.1.1
+ */
+function computeSRTPIV(masterSalt, ssrc, seqNo, roc = 0) {
+    const iv = Buffer.alloc(16, 0);
+    
+    // 48-bit index: (roc << 16) | seqNo
+    const indexBuf = Buffer.alloc(8, 0);
+    indexBuf.writeUInt32BE(roc, 0);
+    indexBuf.writeUInt16BE(seqNo, 4);
+
+    // IV = (ssrc << 64) ^ (index << 16) ^ (masterSalt << 16)
+    masterSalt.copy(iv, 0, 0, 14);
+
+    // XOR SSRC at bytes 4-7
+    iv[4] ^= (ssrc >>> 24) & 0xff;
+    iv[5] ^= (ssrc >>> 16) & 0xff;
+    iv[6] ^= (ssrc >>> 8) & 0xff;
+    iv[7] ^= ssrc & 0xff;
+
+    // XOR index at bytes 6-13
+    for (let i = 0; i < 6; i++) {
+        iv[8 + i] ^= indexBuf[2 + i];
+    }
+
+    return iv;
+}
+
+/**
+ * Encrypts an RTP payload using AES-128-CTR (SRTP Default)
+ */
+function encryptRTPPayload(payload, key, iv) {
+    const cipher = crypto.createCipheriv("aes-128-ctr", key, iv);
+    return Buffer.concat([cipher.update(payload), cipher.final()]);
+}
+
+/**
+ * Decrypts an SRTP payload using AES-128-CTR
+ */
+function decryptRTPPayload(encryptedPayload, key, iv) {
+    const decipher = crypto.createDecipheriv("aes-128-ctr", key, iv);
+    return Buffer.concat([decipher.update(encryptedPayload), decipher.final()]);
+}
+
+/**
+ * Computes HMAC-SHA1-80 authentication tag (10 bytes) for SRTP packet
+ */
+function computeAuthTag(authKey, packetData, roc = 0) {
+    const rocBuf = Buffer.alloc(4);
+    rocBuf.writeUInt32BE(roc, 0);
+
+    const hmac = crypto.createHmac("sha1", authKey);
+    hmac.update(packetData);
+    hmac.update(rocBuf);
+    return hmac.digest().subarray(0, 10);
+}
+
+module.exports = {
+    SRTP_LABEL,
+    hkdfDerive,
+    deriveVoIPKeys,
+    computeSRTPIV,
+    encryptRTPPayload,
+    decryptRTPPayload,
+    computeAuthTag,
+};