kage-baileys 3.0.2 → 3.0.4

package/WAProto/index.js

@@ -3,6 +3,52 @@
 
 var $protobuf = require("protobufjs/minimal");
 
+'use strict';
+// ============================================================================
+// kage fix: decodificador base64 tolerante.
+// Evita "Error: invalid encoding" cuando WhatsApp/devlogs entregan firmas,
+// certificados o hashes con base64 URL-safe, saltos de linea, padding roto
+// o un caracter suelto residual (longitud % 4 === 1). En ese ultimo caso se
+// descarta unicamente el caracter colgante y el resto se decodifica intacto.
+// Este archivo es inyectado automaticamente por scripts/generate-protobuf.cjs
+// al final de WAProto/index.js tras cada regeneracion.
+// ============================================================================
+(function () {
+    var b64 = $protobuf.util.base64;
+    if (b64.__kageTolerant)
+        return;
+    var nativeDecode = b64.decode;
+    var nativeLength = b64.length;
+    var clean = function (string) {
+        var s = $String(string).replace(/[\r\n\t\s]/g, "").replace(/-/g, "+").replace(/_/g, "/");
+        var rem = s.length % 4;
+        if (rem === 2)
+            s += "==";
+        else if (rem === 3)
+            s += "=";
+        else if (rem === 1)
+            s = s.slice(0, -1); // caracter colgante: 6 bits sin datos, no aporta bytes
+        return s;
+    };
+    b64.length = function (string) {
+        if (typeof string !== "string")
+            return nativeLength(string);
+        return nativeLength(clean(string));
+    };
+    b64.decode = function (string, buffer, start) {
+        if (typeof string !== "string")
+            return nativeDecode(string, buffer, start);
+        var s = clean(string);
+        try {
+            return nativeDecode(s, buffer, start);
+        } catch (e) {
+            // ultimo recurso: elimina cualquier caracter residual no-base64
+            return nativeDecode(s.replace(/[^A-Za-z0-9+/=]/g, ""), buffer, start);
+        }
+    };
+    b64.__kageTolerant = true;
+})();
+
 // Common aliases
 var $Reader = $protobuf.Reader, $Writer = $protobuf.Writer, $util = $protobuf.util;
 var $Object = $util.global.Object, $undefined = $util.global.undefined, $Error = $util.global.Error, $RangeError = $util.global.RangeError, $TypeError = $util.global.TypeError, $parseInt = $util.global.parseInt, $BigInt = $util.global.BigInt, $String = $util.global.String, $Number = $util.global.Number, $Array = $util.global.Array, $Boolean = $util.global.Boolean, $isFinite = $util.global.isFinite;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kage-baileys",
-  "version": "3.0.2",
+  "version": "3.0.4",
   "description": "Kage Baileys una libreria de WhatsApp.",
   "keywords": [
     "kage-baileys",
@@ -57,6 +57,7 @@
     "form-data": "^4.0.0",
     "gradient-string": "^2.0.2",
     "jimp": "1.6.1",
+    "kage-baileys": "^3.0.2",
     "libphonenumber-js": "^1.10.20",
     "libsignal": "^6.0.0",
     "link-preview-js": "4.0.4",

package/scripts/generate-protobuf.cjs

@@ -11,10 +11,15 @@ pbjs.main(['-t', 'static-module', '-w', 'commonjs', '--keep-case', '-o', js, pat
     if (error) throw error;
     // Accept plain JSON int64 strings as well as Long instances in toObject.
     let source = fs.readFileSync(js, 'utf8');
+    // kage fix: inyecta decodificador base64 tolerante (evita "Error: invalid encoding"
+    // con base64 URL-safe, saltos de linea, padding roto o un caracter colgante residual
+    // en firmas/certificados de botMetadata.verificationMetadata.proofs).
+    const kageBase64Fix = fs.readFileSync(path.join(__dirname, 'kage-base64-fix.cjs'), 'utf8');
+    source = source.replace('var $protobuf = require("protobufjs/minimal");', 'var $protobuf = require("protobufjs/minimal");\n\n' + kageBase64Fix.trim());
     source = source.replace(/\$util\.Long\.prototype\.toString\.call\((message\.[\w]+)\)/g, 'kageLongString($1)');
     source = source.replace(/new \$util\.LongBits\((message\.[\w]+)\.low >>> 0, \1\.high >>> 0\)\.toNumber\((true)?\)/g, (_, value, unsigned) => `kageLongNumber(${value}, ${!!unsigned})`);
     source = source.replace(/\$util\.Long\.fromBits\((message\.[\w]+)\.low >>> 0, \1\.high >>> 0, (true|false)\)\.toBigInt\(\)/g, (_, value, unsigned) => `BigInt(kageLongString(${value}, ${unsigned}))`);
-    source += `\nfunction kageLongString(value, unsigned) {\n    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'bigint') return String(value);\n    const long = $util.Long.fromValue(value);\n    return (unsigned === true ? long.toUnsigned() : long).toString();\n}\nfunction kageLongNumber(value, unsigned) {\n    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'bigint') return Number(value);\n    const long = $util.Long.fromValue(value);\n    return (unsigned ? long.toUnsigned() : long.toSigned()).toNumber();\n}\nrequire('./compat.cjs')(module.exports.proto);\n`;
+    source += `\nfunction kageLongString(value, unsigned) {\n    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'bigint') return String(value);\n    const long = $util.Long.fromValue(value);\n    return (unsigned === true ? long.toUnsigned() : long).toString();\n}\nfunction kageLongNumber(value, unsigned) {\n    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'bigint') return Number(value);\n    const long = $util.Long.fromValue(value);\n    return (unsigned ? long.toUnsigned() : long.toSigned()).toNumber();\n}\nrequire('./compat.cjs')(module.exports.proto);\n`;  // kage-base64-fix.cjs es leído e inyectado arriba
     fs.writeFileSync(js, source);
     pbts.main(['-o', dts, js], error => {
         if (error) throw error;

package/scripts/kage-base64-fix.cjs

@@ -0,0 +1,45 @@
+'use strict';
+// ============================================================================
+// kage fix: decodificador base64 tolerante.
+// Evita "Error: invalid encoding" cuando WhatsApp/devlogs entregan firmas,
+// certificados o hashes con base64 URL-safe, saltos de linea, padding roto
+// o un caracter suelto residual (longitud % 4 === 1). En ese ultimo caso se
+// descarta unicamente el caracter colgante y el resto se decodifica intacto.
+// Este archivo es inyectado automaticamente por scripts/generate-protobuf.cjs
+// al final de WAProto/index.js tras cada regeneracion.
+// ============================================================================
+(function () {
+    var b64 = $protobuf.util.base64;
+    if (b64.__kageTolerant)
+        return;
+    var nativeDecode = b64.decode;
+    var nativeLength = b64.length;
+    var clean = function (string) {
+        var s = $String(string).replace(/[\r\n\t\s]/g, "").replace(/-/g, "+").replace(/_/g, "/");
+        var rem = s.length % 4;
+        if (rem === 2)
+            s += "==";
+        else if (rem === 3)
+            s += "=";
+        else if (rem === 1)
+            s = s.slice(0, -1); // caracter colgante: 6 bits sin datos, no aporta bytes
+        return s;
+    };
+    b64.length = function (string) {
+        if (typeof string !== "string")
+            return nativeLength(string);
+        return nativeLength(clean(string));
+    };
+    b64.decode = function (string, buffer, start) {
+        if (typeof string !== "string")
+            return nativeDecode(string, buffer, start);
+        var s = clean(string);
+        try {
+            return nativeDecode(s, buffer, start);
+        } catch (e) {
+            // ultimo recurso: elimina cualquier caracter residual no-base64
+            return nativeDecode(s.replace(/[^A-Za-z0-9+/=]/g, ""), buffer, start);
+        }
+    };
+    b64.__kageTolerant = true;
+})();

package/test/base64-fix.test.cjs

@@ -0,0 +1,49 @@
+'use strict';
+// Test del fix base64 tolerante: evita "Error: invalid encoding" en
+// BotSignatureVerificationUseCaseProof (signature / certificateChain).
+const { test } = require('node:test');
+const assert = require('node:assert');
+const path = require('path');
+const WAProto = require(path.join(__dirname, '..', 'WAProto', 'index.js'));
+
+const makeProof = (signature, certificateChain) => ({
+    messageContextInfo: {
+        botMetadata: {
+            verificationMetadata: {
+                proofs: [{ version: 1, useCase: 'WA_BOT_MSG', signature, certificateChain }]
+            }
+        }
+    }
+});
+
+test('base64 estandar con padding correcto se decodifica igual que siempre', () => {
+    const msg = WAProto.proto.Message.fromObject(makeProof('AAAA', ['QQ==']));
+    assert.strictEqual(Buffer.from(msg.messageContextInfo.botMetadata.verificationMetadata.proofs[0].certificateChain[0]).toString(), 'A');
+});
+
+test('base64 URL-safe (- y _) se acepta sin error', () => {
+    // 'a-b_' es URL-safe; en base64 estricto lanzaria invalid encoding por los caracteres
+    const msg = WAProto.proto.Message.fromObject(makeProof('AAAA', ['_-__']));
+    assert.ok(msg.messageContextInfo.botMetadata.verificationMetadata.proofs[0].certificateChain[0].length >= 0);
+});
+
+test('base64 sin padding se completa automaticamente', () => {
+    // 'QQ' (2 chars) sin '==' debe decodificar a 'A'
+    const msg = WAProto.proto.Message.fromObject(makeProof('AAAA', ['QQ']));
+    assert.strictEqual(Buffer.from(msg.messageContextInfo.botMetadata.verificationMetadata.proofs[0].certificateChain[0]).toString(), 'A');
+});
+
+test('base64 con saltos de linea no lanza invalid encoding', () => {
+    const msg = WAProto.proto.Message.fromObject(makeProof('AAAA', ['QQ==\n']));
+    assert.strictEqual(Buffer.from(msg.messageContextInfo.botMetadata.verificationMetadata.proofs[0].certificateChain[0]).toString(), 'A');
+});
+
+test('certificado con caracter colgante (len % 4 === 1) no lanza invalid encoding', () => {
+    // Reproduce el caso real de WhatsApp: cadena de 1169 chars (resto 1).
+    // El caracter colgante se descarta (6 bits sin datos) y el resto se decodifica.
+    const broken = 'TklYRUwuTWVzc2FnZUJ1aWxkZXJWNC43LVZlcmlmaWNhdGlvblNpZ25hdHVyZS5NZXRhZGF0YQ' + 'A';
+    const msg = WAProto.proto.Message.fromObject(makeProof('AAAA', [broken]));
+    const bytes = msg.messageContextInfo.botMetadata.verificationMetadata.proofs[0].certificateChain[0];
+    assert.ok(bytes.length > 0);
+    assert.strictEqual(Buffer.from(bytes).toString('utf8', 0, 8), 'NIXEL.Me');
+});