@yoooloo42/beat 1.0.19 → 1.0.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yoooloo42/beat",
-  "version": "1.0.19",
+  "version": "1.0.21",
   "description": "",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"

package/src/libs/Base64.js

@@ -0,0 +1,121 @@
+import fs from 'fs';
+import path from 'path';
+import https from 'https';
+import http from 'http'; // 也可能需要处理 http 链接
+
+/**
+ * 从本地文件路径获取文件的 Base64 编码。
+ * @param {string} filePath - 本地文件的绝对或相对路径。
+ * @returns {Promise<string>} - 文件的 Base64 编码字符串。
+ */
+function getBase64FromLocalFile(filePath) {
+    return new Promise((resolve, reject) => {
+        // 确保路径是绝对路径
+        const absolutePath = path.resolve(filePath);
+
+        // 使用 { encoding: 'base64' } 直接读取为 Base64 字符串
+        fs.readFile(absolutePath, { encoding: 'base64' }, (err, data) => {
+            if (err) {
+                console.error(`[本地文件错误] 读取本地文件失败: ${err.message}`);
+                return reject(err);
+            }
+            resolve(data);
+        });
+    });
+}
+
+/**
+ * 从远程文件 URL 获取文件的 Base64 编码，支持自动重定向跟随 (3xx 状态码)。
+ * @param {string} fileUrl - 远程文件的完整 URL。
+ * @param {number} [redirects=5] - 最大重定向次数限制。
+ * @returns {Promise<string>} - 文件的 Base64 编码字符串。
+ */
+function getBase64FromURL(fileUrl, redirects = 5) {
+    if (redirects === 0) {
+        return Promise.reject(new Error(`[远程文件错误] 重定向次数过多 (${fileUrl})`));
+    }
+
+    // 根据 URL 协议选择合适的模块
+    const client = fileUrl.startsWith('https') ? https : http;
+
+    return new Promise((resolve, reject) => {
+        client.get(fileUrl, (res) => {
+            const statusCode = res.statusCode;
+
+            // --- 处理重定向 (3xx 状态码) ---
+            if (statusCode >= 300 && statusCode < 400 && res.headers.location) {
+                const newUrl = res.headers.location;
+                console.log(`[重定向] 遇到状态码 ${statusCode}，重定向至: ${newUrl}`);
+                // 递归调用自身，跟随重定向
+                return getBase64FromURL(newUrl, redirects - 1)
+                    .then(resolve)
+                    .catch(reject);
+            }
+
+            // --- 处理请求失败 (4xx, 5xx) ---
+            if (statusCode < 200 || statusCode >= 400) {
+                return reject(new Error(`[远程文件错误] 请求失败，状态码: ${statusCode} (${fileUrl})`));
+            }
+
+            // --- 成功获取 (2xx) ---
+            const chunks = [];
+            res.on('data', (chunk) => {
+                chunks.push(chunk);
+            });
+
+            res.on('end', () => {
+                try {
+                    // 合并所有 Buffer 块并转换为 Base64 字符串
+                    const buffer = Buffer.concat(chunks);
+                    const base64String = buffer.toString('base64');
+                    resolve(base64String);
+                } catch (e) {
+                    reject(new Error(`[远程文件错误] 处理远程文件数据失败: ${e.message}`));
+                }
+            });
+
+        }).on('error', (err) => {
+            console.error(`[远程文件错误] 远程请求连接错误: ${err.message}`);
+            reject(err);
+        });
+    });
+}
+
+/*
+// ------------------------------------
+//          示例执行
+// ------------------------------------
+
+// 1. 本地文件示例（请确保 'test.bmp' 存在于同一目录下）
+// 注意：如果文件不存在，会捕获到错误。
+getBase64FromLocalFile('Base64.js.test.png')
+    .then(base64String => {
+        console.log('\n--- 本地文件结果 ---');
+        console.log(`本地文件的 Base64 编码长度: ${base64String.length}`);
+        console.log(`本地文件的 Base64 编码 (前50字符): ${base64String.substring(0, 50)}...`);
+    })
+    .catch(error => {
+        // 捕获本地文件不存在或权限不足的错误
+        console.error('\n--- 本地文件错误 ---');
+        console.error('获取本地文件 Base64 失败:', error.message);
+    });
+
+// 2. 远程 URL 示例（使用支持重定向的函数）
+const remoteUrl = 'https://picsum.photos/200/300'; // 这个 URL 会导致 302 重定向
+getBase64FromURL(remoteUrl)
+    .then(base64String => {
+        console.log('\n--- 远程文件结果 ---');
+        console.log(`远程文件的 Base64 编码长度: ${base64String.length}`);
+        console.log(`远程文件的 Base64 编码 (前50字符): ${base64String.substring(0, 50)}...`);
+    })
+    .catch(error => {
+        // 捕获请求失败或重定向超时的错误
+        console.error('\n--- 远程文件错误 ---');
+        console.error('获取远程文件 Base64 失败:', error.message);
+    });
+*/
+
+export default {
+    getBase64FromLocalFile,
+    getBase64FromURL
+}

package/src/libs/crypto/AES.js

@@ -4,74 +4,66 @@ import crypto from 'crypto';
 const ALGORITHM = 'aes-128-cbc'; // 算法：AES-128-CBC
 const IV_LENGTH = 16;          // IV 长度：16 字节 (128 位)
 const KEY_LENGTH = 16;         // 密钥长度：16 字节 (128 位)
-const INPUT_ENCODING = 'utf8'; // 明文输入编码
-const OUTPUT_FORMAT = 'base64';// 密文输出格式 (通常用 Base64 或 Hex)
+const PLAINTEXT_ENCODING = 'utf8'; // 明文输入编码
+const CIPHER_OUTPUT_FORMAT = 'base64';// 密文输出格式 (Base64)
+const KEY_IV_FORMAT = 'base64'; // 密钥和 IV 的传输/存储格式 (Base64)
 
 /**
  * 🔑 生成安全随机的 AES 密钥和 IV。
- * 密钥和 IV 应仅生成一次，并安全地存储（例如，作为环境变量或安全配置文件）。
- *
- * @returns {Object} 包含 base64 格式密钥和 IV 的对象
+ * @returns {Object} 包含 Base64 格式密钥和 IV 的对象
  */
 function generateKeyAndIV() {
-    // 使用 cryptographically secure pseudo-random number generator (CSPRNG)
-    // Node.js 的 crypto.randomBytes 保证了生成的随机性。
-    const key = crypto.randomBytes(KEY_LENGTH).toString(OUTPUT_FORMAT);
-    const iv = crypto.randomBytes(IV_LENGTH).toString(OUTPUT_FORMAT);
+    // 使用 KEY_IV_FORMAT (Base64) 输出，以便于存储和传输
+    const key = crypto.randomBytes(KEY_LENGTH).toString(KEY_IV_FORMAT);
+    const iv = crypto.randomBytes(IV_LENGTH).toString(KEY_IV_FORMAT);
 
     return {
-        key: key, // Base64 格式的 16 字节密钥
-        iv: iv    // Base64 格式的 16 字节 IV
+        key: key, // Base64 格式的 16 字节密钥（长度为 24 的字符串）
+        iv: iv    // Base64 格式的 16 字节 IV（长度为 24 的字符串）
     };
 }
-// 示例用法：
-// const { key, iv } = generateKeyAndIV();
-// console.log("Key:", key);
-// console.log("IV:", iv);
-
 
 /**
  * 检查密钥和初始化向量的长度是否符合 AES-128-CBC 规范。
+ * 注意：这里的 Buffer 长度必须是 KEY_LENGTH/IV_LENGTH (16 字节)
  * @param {Buffer} keyBuffer 密钥 Buffer
  * @param {Buffer} ivBuffer 初始化向量 Buffer
  */
 function checkKeyAndIV(keyBuffer, ivBuffer) {
     if (keyBuffer.length !== KEY_LENGTH) {
-        throw new Error(`Invalid Key Length. Key must be ${KEY_LENGTH} bytes for ${ALGORITHM}.`);
+        throw new Error(`Invalid Key Length. Key must be ${KEY_LENGTH} bytes for ${ALGORITHM}. Current buffer size: ${keyBuffer.length}`);
     }
     if (ivBuffer.length !== IV_LENGTH) {
-        throw new Error(`Invalid IV Length. IV must be ${IV_LENGTH} bytes for ${ALGORITHM}.`);
+        throw new Error(`Invalid IV Length. IV must be ${IV_LENGTH} bytes for ${ALGORITHM}. Current buffer size: ${ivBuffer.length}`);
     }
 }
 
 /**
  * 🔐 AES-128-CBC 加密
- * 使用内置 crypto 模块，默认使用 PKCS7 自动补位。
  * @param {Object} params
  * @param {string} params.text - 明文
- * @param {string} params.key - 16字节的密钥字符串
- * @param {string} params.iv - 16字节的初始化向量字符串
+ * @param {string} params.key - Base64 格式的密钥字符串
+ * @param {string} params.iv - Base64 格式的初始化向量字符串
  * @returns {string} Base64 格式的密文
  */
 function aesEncrypt({ text, key, iv }) {
     try {
-        const keyBuffer = Buffer.from(key, INPUT_ENCODING);
-        const ivBuffer = Buffer.from(iv, INPUT_ENCODING);
+        // 关键修复：使用 KEY_IV_FORMAT (Base64) 来解析输入的 Key 和 IV 字符串
+        const keyBuffer = Buffer.from(key, KEY_IV_FORMAT);
+        const ivBuffer = Buffer.from(iv, KEY_IV_FORMAT);
 
         checkKeyAndIV(keyBuffer, ivBuffer);
 
-        // 1. 创建加密器，默认自动 PKCS7 补位
         const cipher = crypto.createCipheriv(ALGORITHM, keyBuffer, ivBuffer);
 
-        // 2. 加密主体
-        // textBuffer 是 Buffer，所以不需要第二个 'utf8' 参数，但为了清晰，使用 INPUT_ENCODING
-        let encrypted = cipher.update(text, INPUT_ENCODING, 'hex');
+        // 加密主体：输入是明文 (PLAINTEXT_ENCODING)，输出为 Hex
+        let encrypted = cipher.update(text, PLAINTEXT_ENCODING, 'hex');
 
-        // 3. 完成加密，并应用最终补位
+        // 完成加密，并应用最终补位
         encrypted += cipher.final('hex');
 
-        // 4. 将 Hex 转换为 Base64 输出
-        return Buffer.from(encrypted, 'hex').toString(OUTPUT_FORMAT);
+        // 将 Hex 转换为 Base64 输出
+        return Buffer.from(encrypted, 'hex').toString(CIPHER_OUTPUT_FORMAT);
 
     } catch (error) {
         console.error("AES Encryption Error:", error.message);
@@ -81,31 +73,31 @@ function aesEncrypt({ text, key, iv }) {
 
 /**
  * 🔓 AES-128-CBC 解密
- * 使用内置 crypto 模块，自动移除 PKCS7 补位。
  * @param {Object} params
  * @param {string} params.text - Base64 格式的密文
- * @param {string} params.key - 16字节的密钥字符串
- * @param {string} params.iv - 16字节的初始化向量字符串
+ * @param {string} params.key - Base64 格式的密钥字符串
+ * @param {string} params.iv - Base64 格式的初始化向量字符串
  * @returns {string} 明文
  */
 function aesDecrypt({ text, key, iv }) {
     try {
-        const keyBuffer = Buffer.from(key, INPUT_ENCODING);
-        const ivBuffer = Buffer.from(iv, INPUT_ENCODING);
+        // 关键修复：使用 KEY_IV_FORMAT (Base64) 来解析输入的 Key 和 IV 字符串
+        const keyBuffer = Buffer.from(key, KEY_IV_FORMAT);
+        const ivBuffer = Buffer.from(iv, KEY_IV_FORMAT);
+
         checkKeyAndIV(keyBuffer, ivBuffer);
 
         // 1. 将 Base64 密文转为 Buffer
-        const encryptedBuffer = Buffer.from(text, OUTPUT_FORMAT);
+        const encryptedBuffer = Buffer.from(text, CIPHER_OUTPUT_FORMAT);
 
-        // 2. 创建解密器，默认自动移除补位 (Auto Padding: true)
+        // 2. 创建解密器
         const decipher = crypto.createDecipheriv(ALGORITHM, keyBuffer, ivBuffer);
 
-        // 3. 解密主体
-        // 因为输入是 Buffer，所以第二个参数可以省略或使用 'buffer'
-        let decrypted = decipher.update(encryptedBuffer, 'buffer', INPUT_ENCODING);
+        // 3. 解密主体：输入是 Buffer，输出为明文编码
+        let decrypted = decipher.update(encryptedBuffer, 'buffer', PLAINTEXT_ENCODING);
 
         // 4. 完成解密，并移除补位
-        decrypted += decipher.final(INPUT_ENCODING);
+        decrypted += decipher.final(PLAINTEXT_ENCODING);
 
         return decrypted;
     } catch (error) {
@@ -115,8 +107,27 @@ function aesDecrypt({ text, key, iv }) {
     }
 }
 
+// --- 测试和导出 ---
+
+// 测试代码部分（请在文件外部执行时使用，或在 Node.js 环境中移除 export default 后测试）
+/*
+const { key, iv } = generateKeyAndIV()
+console.log("Key:", key);
+console.log(key.length); // 应该是 Base64 字符串长度 24
+console.log("IV:", iv);
+console.log(iv.length);   // 应该是 Base64 字符串长度 24
+const text = 'Hello Gemini'
+try {
+    const ciphertext = aesEncrypt({text: text, key, iv})
+    console.log('加密测试：', ciphertext)
+    const decryptedText = aesDecrypt({text: ciphertext, key, iv})
+    console.log('解密测试：', decryptedText)
+} catch (e) {
+    console.error('测试失败:', e.message)
+}
+*/
+
 export default {
-    // 推荐使用
     generateKeyAndIV,
     checkKeyAndIV,
     aesEncrypt,

package/src/libs/crypto/RSA.js

@@ -5,6 +5,29 @@ const ALGORITHM = 'RSA-SHA256';
 const INPUT_ENCODING = 'utf8';
 const SIGNATURE_FORMAT = 'base64';
 
+/**
+ * 🔑 生成 RSA 密钥对 (公钥和私钥)。
+ *
+ * @returns {Object} 包含公钥和私钥的对象 (PEM 格式)
+ */
+function generateRSAKeyPair() {
+    // 使用 generateKeyPairSync 同步生成 RSA 密钥对
+    const { publicKey, privateKey } = crypto.generateKeyPairSync('rsa', {
+        modulusLength: 2048, // 密钥长度，2048 位是目前推荐的最小安全长度
+        publicKeyEncoding: {
+            type: 'spki',       // SubjectPublicKeyInfo 格式
+            format: 'pem'       // PEM 格式
+        },
+        privateKeyEncoding: {
+            type: 'pkcs8',      // PKCS#8 格式
+            format: 'pem'       // PEM 格式
+            // 生产环境建议添加 cipher: 'aes-256-cbc' 和 passphrase 来加密私钥
+        }
+    });
+
+    return { publicKey, privateKey };
+}
+
 /**
  * 🔐 RSA 签名
  * 使用 'RSA-SHA256' 算法，将输入文本进行签名。
@@ -21,20 +44,15 @@ function rsaSign({ text, privateKey }) {
     }
 
     try {
-        // 使用 const 声明，保持不变性
         const signer = crypto.createSign(ALGORITHM);
-
-        // 优化：将数据直接传递给 update，无需再调用 end()
         signer.update(text, INPUT_ENCODING);
 
-        // 签名，并指定私钥和输出格式
-        // 'base64' 是默认格式，但显式指定更清晰
+        // 签名
         const signature = signer.sign(privateKey, SIGNATURE_FORMAT);
 
         return signature;
 
     } catch (error) {
-        // 捕获密钥格式错误、权限错误等
         console.error(`RSA Signing Error (${ALGORITHM}):`, error.message);
         throw new Error("RSA signing failed. Check private key format and validity.");
     }
@@ -53,21 +71,15 @@ function rsaSign({ text, privateKey }) {
  */
 function rsaVerify({ text, signature, publicKey }) {
     if (!text || !signature || !publicKey) {
-        // 参数缺失时，直接返回 false 或抛出错误，这里选择返回 false 兼容原逻辑，但推荐抛出错误
         console.warn("Missing required parameters for verification.");
         return false;
     }
 
     try {
-        // 使用 const 声明
         const verifier = crypto.createVerify(ALGORITHM);
-
-        // 优化：将数据直接传递给 update
         verifier.update(text, INPUT_ENCODING);
 
         // 验证签名
-        // signature 已经是 Base64 格式的 Buffer，不需要再调用 Buffer.from() 转换
-        // verifier.verify 会自动处理公钥和签名格式
         return verifier.verify(
             publicKey,
             signature,
@@ -75,14 +87,54 @@ function rsaVerify({ text, signature, publicKey }) {
         );
 
     } catch (error) {
-        // 捕获公钥格式错误等
         console.error(`RSA Verification Error (${ALGORITHM}):`, error.message);
-        // 验证过程失败通常意味着配置或密钥有误，应抛出错误而不是返回 false
         throw new Error("RSA verification failed due to internal error. Check public key format and validity.");
     }
 }
 
+/* --- 测试代码 ---
+try {
+    const dataToSign = "这是一段需要使用数字签名的重要数据。";
+
+    // 1. 生成密钥对
+    console.log("--- 1. 生成 RSA 密钥对 ---");
+    const { publicKey, privateKey } = generateRSAKeyPair();
+    // console.log("私钥 (PEM):", privateKey);
+    // console.log("公钥 (PEM):", publicKey);
+
+    // 2. 使用私钥签名
+    console.log("\n--- 2. 进行签名 ---");
+    const signature = rsaSign({ text: dataToSign, privateKey: privateKey });
+    console.log("原始数据:", dataToSign);
+    console.log("签名结果 (Base64):", signature);
+
+    // 3. 使用公钥验证
+    console.log("\n--- 3. 验证签名 ---");
+    const isValid = rsaVerify({
+        text: dataToSign,
+        signature: signature,
+        publicKey: publicKey
+    });
+    console.log("验证结果 (正确签名):", isValid ? "✅ 验证通过" : "❌ 验证失败");
+
+    // 4. 验证失败场景 (数据篡改)
+    console.log("\n--- 4. 验证失败测试 (数据篡改) ---");
+    const tamperedData = "这是一段被篡改后的数据！";
+    const isInvalid = rsaVerify({
+        text: tamperedData, // 使用篡改后的数据
+        signature: signature,
+        publicKey: publicKey
+    });
+    console.log("验证结果 (篡改数据):", isInvalid ? "❌ 验证通过 (错误)" : "✅ 验证失败 (正确)");
+
+} catch (error) {
+    console.error("\n--- RSA 测试发生错误 ---");
+    console.error(error.message);
+}
+*/
+
 export default {
-    rsaSign,      // 优化后的函数名，更简洁
+    generateRSAKeyPair,
+    rsaSign,
     rsaVerify
-}
+}