@jayfong/x-server 2.64.0 → 2.66.0

package/lib/_cjs/index.js

@@ -1,6 +1,12 @@
 "use strict";
 
 exports.__esModule = true;
+var _ctx_storage = require("./core/ctx_storage");
+Object.keys(_ctx_storage).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _ctx_storage[key]) return;
+  exports[key] = _ctx_storage[key];
+});
 var _define_bus = require("./core/define_bus");
 Object.keys(_define_bus).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -145,6 +151,12 @@ Object.keys(_captcha).forEach(function (key) {
   if (key in exports && exports[key] === _captcha[key]) return;
   exports[key] = _captcha[key];
 });
+var _crypto = require("./services/crypto");
+Object.keys(_crypto).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _crypto[key]) return;
+  exports[key] = _crypto[key];
+});
 var _db_value = require("./services/db_value");
 Object.keys(_db_value).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;

package/lib/_cjs/services/crypto.js

@@ -0,0 +1,175 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.CryptoService = void 0;
+var _nodeCrypto = _interopRequireDefault(require("node:crypto"));
+class CryptoService {
+  constructor() {
+    this.serviceName = 'crypto';
+  }
+  /**
+   * 将给定的文本转换为 Base64 编码的字符串
+   *
+   * @param text 需要编码的原始文本
+   * @returns 返回 Base64 编码后的字符串
+   */
+  base64Encode(text) {
+    return Buffer.from(text).toString('base64');
+  }
+
+  /**
+   * 将 Base64 编码的字符串转换为 UTF-8 编码的字符串
+   *
+   * @param text Base64 编码的字符串
+   * @returns 转换后的 UTF-8 编码的字符串
+   */
+  base64Decode(text) {
+    return Buffer.from(text, 'base64').toString('utf8');
+  }
+
+  /**
+   * 将字符串文本编码为Base64 URL格式
+   *
+   * 此函数的目的是将输入的字符串转换为Base64编码，并进一步转换为URL安全的格式
+   * Base64标准字符集中的'+'和'/'在URL中有特殊意义，因此需要被替换为'-'和'_'
+   * 此外，Base64编码中用于填充的'='字符在URL中通常被视为不必要的，因此也会被移除
+   *
+   * @param text 需要被编码的字符串文本
+   * @returns 编码后的Base64 URL安全字符串
+   */
+  base64UrlEncode(text) {
+    // 将输入文本转换为Buffer对象，并进一步将其转换为Base64编码的字符串
+    let base64 = Buffer.from(text).toString('base64');
+
+    // 将Base64编码中的'+'替换为'-'，以适应URL安全要求
+    base64 = base64.replace(/\+/g, '-');
+
+    // 将Base64编码中的'/'替换为'_'，以适应URL安全要求
+    base64 = base64.replace(/\//g, '_');
+
+    // 移除Base64编码中用于填充的'='字符，以适应URL安全要求
+    base64 = base64.replace(/=/g, '');
+
+    // 返回经过URL安全处理的Base64编码字符串
+    return base64;
+  }
+
+  /**
+   * 解码base64url格式的字符串
+   * base64url是一种用于URL的base64编码变体，它将标准base64中的'+'和'/'字符替换为'-'和'_'，以避免URL编码
+   * 此函数的作用是将base64url编码的字符串解码回原始字符串
+   *
+   * @param text 需要解码的base64url格式的字符串
+   * @returns 解码后的原始字符串
+   */
+  base64UrlDecode(text) {
+    // 将base64url编码中的'-'和'_'替换回标准base64编码中的'+'和'/'
+    // 然后使用Node.js的Buffer对象从base64编码转换为utf8格式的字符串
+    return Buffer.from(text.replace(/-/g, '+').replace(/_/g, '/'), 'base64').toString('utf8');
+  }
+
+  /**
+   * 使用MD5算法对文本进行哈希处理
+   *
+   * @param text 需要进行哈希处理的文本
+   * @returns 返回经过MD5哈希处理后的字符串
+   */
+  md5(text) {
+    return _nodeCrypto.default.createHash('md5').update(text).digest('hex');
+  }
+
+  /**
+   * 使用SHA-1算法对文本进行哈希处理
+   *
+   * SHA-1是一种安全散列算法，它接收一个输入（在此例中为文本字符串），
+   * 并返回一个固定大小的160位散列值，通常以40位的十六进制数字表示
+   * 此函数用于将给定的文本转换为SHA-1散列值，常用于数据完整性校验或存储密码的散列值
+   *
+   * @param text 待哈希处理的文本字符串
+   * @returns 返回文本的SHA-1散列值，以十六进制字符串形式表示
+   */
+  sha1(text) {
+    return _nodeCrypto.default.createHash('sha1').update(text).digest('hex');
+  }
+
+  /**
+   * 使用SHA-256算法对文本进行哈希处理
+   *
+   * @param text 输入的文本字符串
+   * @returns 返回经过SHA-256哈希处理后的十六进制字符串
+   */
+  sha256(text) {
+    return _nodeCrypto.default.createHash('sha256').update(text).digest('hex');
+  }
+
+  /**
+   * 使用SHA-512算法对文本进行哈希处理
+   *
+   * @param text 输入的文本字符串
+   * @returns 返回经过SHA-512哈希处理后的字符串
+   */
+  sha512(text) {
+    return _nodeCrypto.default.createHash('sha512').update(text).digest('hex');
+  }
+
+  /**
+   * 使用给定的密钥对给定的字符串执行 AES 加密（加密模式为 ECB，填充方式为 PKCS7）。
+   *
+   * @param text - 要加密的字符串。
+   * @param key - 用于加密的密钥（仅支持16字节的密钥）。
+   */
+  aesEncrypt(text, key) {
+    const cipher = _nodeCrypto.default.createCipheriv('aes-128-ecb', key, null);
+    let encrypted = cipher.update(text, 'utf8', 'base64');
+    encrypted += cipher.final('base64');
+    return encrypted;
+  }
+
+  /**
+   * 使用给定的密钥对给定的字符串执行 AES 解密（解密模式为 ECB，填充方式为 PKCS7）。
+   *
+   * @param text - 要解密的字符串。
+   * @param key - 用于解密的密钥（仅支持16字节的密钥）。
+   */
+  aesDecrypt(text, key) {
+    const decipher = _nodeCrypto.default.createDecipheriv('aes-128-ecb', key, null);
+    let decrypted = decipher.update(text, 'base64', 'utf8');
+    decrypted += decipher.final('utf8');
+    return decrypted;
+  }
+
+  /**
+   * 使用AES加密算法对JSON数据进行加密
+   *
+   * 该方法首先将payload参数序列化为JSON字符串，然后使用指定的密钥进行AES加密
+   * 主要用于在传输敏感信息前，对数据进行加密处理，以确保数据的安全性
+   *
+   * @param payload 任何类型的对象，代表需要加密的原始数据
+   * @param key 字符串类型的密钥，用于AES加密算法
+   *            密钥需要符合AES加密算法的长度要求
+   * @returns 返回加密后的字符串数据
+   *          加密后的数据可以安全地进行网络传输或存储
+   */
+  aesEncryptJson(payload, key) {
+    // 将payload对象序列化为JSON字符串，以便进行加密处理
+    // 使用指定的密钥对序列化后的JSON字符串进行AES加密
+    // 返回加密后的数据，确保数据在传输或存储过程中的安全性
+    return this.aesEncrypt(JSON.stringify(payload), key);
+  }
+
+  /**
+   * 使用AES算法解密给定的文本，并将解密后的结果解析为JSON对象
+   *
+   * @param text 需要解密的加密文本
+   * @param key 解密用的密钥，必须与加密时使用的密钥相同
+   * @returns 返回解密后的JSON对象，类型为泛型T，根据调用时指定的类型解析
+   */
+  aesDecryptJson(text, key) {
+    // 使用指定的密钥对给定的加密数据进行AES解密
+    // 将解密后的数据反序列化为JSON对象，以便后续的处理
+    // 返回解密后的数据，确保数据在传输或存储过程中的安全性
+    return JSON.parse(this.aesDecrypt(text, key));
+  }
+}
+exports.CryptoService = CryptoService;

package/lib/_cjs/x.js

@@ -7,6 +7,7 @@ var _os = _interopRequireDefault(require("os"));
 var _path = _interopRequireDefault(require("path"));
 var _fsExtra = _interopRequireDefault(require("fs-extra"));
 var _ctx_storage = require("./core/ctx_storage");
+var _crypto = require("./services/crypto");
 var _db_value = require("./services/db_value");
 var _dispose = require("./services/dispose");
 var _emoji = require("./services/emoji");
@@ -29,4 +30,4 @@ const x = exports.x = {
 _fsExtra.default.ensureDirSync(x.dataDir);
 x.register(new _dispose.DisposeService({
   disposeOnExit: true
-}), new _log.LogService(), new _emoji.EmojiService(), new _db_value.DbValueService());
+}), new _log.LogService(), new _emoji.EmojiService(), new _db_value.DbValueService(), new _crypto.CryptoService());

package/lib/index.d.ts

@@ -1,3 +1,4 @@
+export * from './core/ctx_storage';
 export * from './core/define_bus';
 export * from './core/define_cron';
 export * from './core/define_handler';
@@ -22,6 +23,7 @@ export * from './plugins/xml_parser';
 export * from './services/base';
 export * from './services/cache';
 export * from './services/captcha';
+export * from './services/crypto';
 export * from './services/db_value';
 export * from './services/dingtalk';
 export * from './services/dispose';

package/lib/index.js

@@ -1,4 +1,5 @@
 // @index(['./**/*.ts', '!**/*.test.ts', '!./cli/**', '!**/_*'], f => `export * from '${f.path}';`)
+export * from "./core/ctx_storage";
 export * from "./core/define_bus";
 export * from "./core/define_cron";
 export * from "./core/define_handler";
@@ -23,6 +24,7 @@ export * from "./plugins/xml_parser";
 export * from "./services/base";
 export * from "./services/cache";
 export * from "./services/captcha";
+export * from "./services/crypto";
 export * from "./services/db_value";
 export * from "./services/dingtalk";
 export * from "./services/dispose";

package/lib/services/crypto.d.ts

@@ -0,0 +1,110 @@
+import { BaseService } from './base';
+export declare class CryptoService implements BaseService {
+    serviceName: string;
+    /**
+     * 将给定的文本转换为 Base64 编码的字符串
+     *
+     * @param text 需要编码的原始文本
+     * @returns 返回 Base64 编码后的字符串
+     */
+    base64Encode(text: string): string;
+    /**
+     * 将 Base64 编码的字符串转换为 UTF-8 编码的字符串
+     *
+     * @param text Base64 编码的字符串
+     * @returns 转换后的 UTF-8 编码的字符串
+     */
+    base64Decode(text: string): string;
+    /**
+     * 将字符串文本编码为Base64 URL格式
+     *
+     * 此函数的目的是将输入的字符串转换为Base64编码，并进一步转换为URL安全的格式
+     * Base64标准字符集中的'+'和'/'在URL中有特殊意义，因此需要被替换为'-'和'_'
+     * 此外，Base64编码中用于填充的'='字符在URL中通常被视为不必要的，因此也会被移除
+     *
+     * @param text 需要被编码的字符串文本
+     * @returns 编码后的Base64 URL安全字符串
+     */
+    base64UrlEncode(text: string): string;
+    /**
+     * 解码base64url格式的字符串
+     * base64url是一种用于URL的base64编码变体，它将标准base64中的'+'和'/'字符替换为'-'和'_'，以避免URL编码
+     * 此函数的作用是将base64url编码的字符串解码回原始字符串
+     *
+     * @param text 需要解码的base64url格式的字符串
+     * @returns 解码后的原始字符串
+     */
+    base64UrlDecode(text: string): string;
+    /**
+     * 使用MD5算法对文本进行哈希处理
+     *
+     * @param text 需要进行哈希处理的文本
+     * @returns 返回经过MD5哈希处理后的字符串
+     */
+    md5(text: string): string;
+    /**
+     * 使用SHA-1算法对文本进行哈希处理
+     *
+     * SHA-1是一种安全散列算法，它接收一个输入（在此例中为文本字符串），
+     * 并返回一个固定大小的160位散列值，通常以40位的十六进制数字表示
+     * 此函数用于将给定的文本转换为SHA-1散列值，常用于数据完整性校验或存储密码的散列值
+     *
+     * @param text 待哈希处理的文本字符串
+     * @returns 返回文本的SHA-1散列值，以十六进制字符串形式表示
+     */
+    sha1(text: string): string;
+    /**
+     * 使用SHA-256算法对文本进行哈希处理
+     *
+     * @param text 输入的文本字符串
+     * @returns 返回经过SHA-256哈希处理后的十六进制字符串
+     */
+    sha256(text: string): string;
+    /**
+     * 使用SHA-512算法对文本进行哈希处理
+     *
+     * @param text 输入的文本字符串
+     * @returns 返回经过SHA-512哈希处理后的字符串
+     */
+    sha512(text: string): string;
+    /**
+     * 使用给定的密钥对给定的字符串执行 AES 加密（加密模式为 ECB，填充方式为 PKCS7）。
+     *
+     * @param text - 要加密的字符串。
+     * @param key - 用于加密的密钥（仅支持16字节的密钥）。
+     */
+    aesEncrypt(text: string, key: string): string;
+    /**
+     * 使用给定的密钥对给定的字符串执行 AES 解密（解密模式为 ECB，填充方式为 PKCS7）。
+     *
+     * @param text - 要解密的字符串。
+     * @param key - 用于解密的密钥（仅支持16字节的密钥）。
+     */
+    aesDecrypt(text: string, key: string): string;
+    /**
+     * 使用AES加密算法对JSON数据进行加密
+     *
+     * 该方法首先将payload参数序列化为JSON字符串，然后使用指定的密钥进行AES加密
+     * 主要用于在传输敏感信息前，对数据进行加密处理，以确保数据的安全性
+     *
+     * @param payload 任何类型的对象，代表需要加密的原始数据
+     * @param key 字符串类型的密钥，用于AES加密算法
+     *            密钥需要符合AES加密算法的长度要求
+     * @returns 返回加密后的字符串数据
+     *          加密后的数据可以安全地进行网络传输或存储
+     */
+    aesEncryptJson(payload: any, key: string): string;
+    /**
+     * 使用AES算法解密给定的文本，并将解密后的结果解析为JSON对象
+     *
+     * @param text 需要解密的加密文本
+     * @param key 解密用的密钥，必须与加密时使用的密钥相同
+     * @returns 返回解密后的JSON对象，类型为泛型T，根据调用时指定的类型解析
+     */
+    aesDecryptJson<T>(text: string, key: string): T;
+}
+declare module '../x' {
+    interface X {
+        crypto: CryptoService;
+    }
+}

package/lib/services/crypto.js

@@ -0,0 +1,169 @@
+import crypto from 'node:crypto';
+export class CryptoService {
+  constructor() {
+    this.serviceName = 'crypto';
+  }
+  /**
+   * 将给定的文本转换为 Base64 编码的字符串
+   *
+   * @param text 需要编码的原始文本
+   * @returns 返回 Base64 编码后的字符串
+   */
+  base64Encode(text) {
+    return Buffer.from(text).toString('base64');
+  }
+
+  /**
+   * 将 Base64 编码的字符串转换为 UTF-8 编码的字符串
+   *
+   * @param text Base64 编码的字符串
+   * @returns 转换后的 UTF-8 编码的字符串
+   */
+  base64Decode(text) {
+    return Buffer.from(text, 'base64').toString('utf8');
+  }
+
+  /**
+   * 将字符串文本编码为Base64 URL格式
+   *
+   * 此函数的目的是将输入的字符串转换为Base64编码，并进一步转换为URL安全的格式
+   * Base64标准字符集中的'+'和'/'在URL中有特殊意义，因此需要被替换为'-'和'_'
+   * 此外，Base64编码中用于填充的'='字符在URL中通常被视为不必要的，因此也会被移除
+   *
+   * @param text 需要被编码的字符串文本
+   * @returns 编码后的Base64 URL安全字符串
+   */
+  base64UrlEncode(text) {
+    // 将输入文本转换为Buffer对象，并进一步将其转换为Base64编码的字符串
+    let base64 = Buffer.from(text).toString('base64');
+
+    // 将Base64编码中的'+'替换为'-'，以适应URL安全要求
+    base64 = base64.replace(/\+/g, '-');
+
+    // 将Base64编码中的'/'替换为'_'，以适应URL安全要求
+    base64 = base64.replace(/\//g, '_');
+
+    // 移除Base64编码中用于填充的'='字符，以适应URL安全要求
+    base64 = base64.replace(/=/g, '');
+
+    // 返回经过URL安全处理的Base64编码字符串
+    return base64;
+  }
+
+  /**
+   * 解码base64url格式的字符串
+   * base64url是一种用于URL的base64编码变体，它将标准base64中的'+'和'/'字符替换为'-'和'_'，以避免URL编码
+   * 此函数的作用是将base64url编码的字符串解码回原始字符串
+   *
+   * @param text 需要解码的base64url格式的字符串
+   * @returns 解码后的原始字符串
+   */
+  base64UrlDecode(text) {
+    // 将base64url编码中的'-'和'_'替换回标准base64编码中的'+'和'/'
+    // 然后使用Node.js的Buffer对象从base64编码转换为utf8格式的字符串
+    return Buffer.from(text.replace(/-/g, '+').replace(/_/g, '/'), 'base64').toString('utf8');
+  }
+
+  /**
+   * 使用MD5算法对文本进行哈希处理
+   *
+   * @param text 需要进行哈希处理的文本
+   * @returns 返回经过MD5哈希处理后的字符串
+   */
+  md5(text) {
+    return crypto.createHash('md5').update(text).digest('hex');
+  }
+
+  /**
+   * 使用SHA-1算法对文本进行哈希处理
+   *
+   * SHA-1是一种安全散列算法，它接收一个输入（在此例中为文本字符串），
+   * 并返回一个固定大小的160位散列值，通常以40位的十六进制数字表示
+   * 此函数用于将给定的文本转换为SHA-1散列值，常用于数据完整性校验或存储密码的散列值
+   *
+   * @param text 待哈希处理的文本字符串
+   * @returns 返回文本的SHA-1散列值，以十六进制字符串形式表示
+   */
+  sha1(text) {
+    return crypto.createHash('sha1').update(text).digest('hex');
+  }
+
+  /**
+   * 使用SHA-256算法对文本进行哈希处理
+   *
+   * @param text 输入的文本字符串
+   * @returns 返回经过SHA-256哈希处理后的十六进制字符串
+   */
+  sha256(text) {
+    return crypto.createHash('sha256').update(text).digest('hex');
+  }
+
+  /**
+   * 使用SHA-512算法对文本进行哈希处理
+   *
+   * @param text 输入的文本字符串
+   * @returns 返回经过SHA-512哈希处理后的字符串
+   */
+  sha512(text) {
+    return crypto.createHash('sha512').update(text).digest('hex');
+  }
+
+  /**
+   * 使用给定的密钥对给定的字符串执行 AES 加密（加密模式为 ECB，填充方式为 PKCS7）。
+   *
+   * @param text - 要加密的字符串。
+   * @param key - 用于加密的密钥（仅支持16字节的密钥）。
+   */
+  aesEncrypt(text, key) {
+    const cipher = crypto.createCipheriv('aes-128-ecb', key, null);
+    let encrypted = cipher.update(text, 'utf8', 'base64');
+    encrypted += cipher.final('base64');
+    return encrypted;
+  }
+
+  /**
+   * 使用给定的密钥对给定的字符串执行 AES 解密（解密模式为 ECB，填充方式为 PKCS7）。
+   *
+   * @param text - 要解密的字符串。
+   * @param key - 用于解密的密钥（仅支持16字节的密钥）。
+   */
+  aesDecrypt(text, key) {
+    const decipher = crypto.createDecipheriv('aes-128-ecb', key, null);
+    let decrypted = decipher.update(text, 'base64', 'utf8');
+    decrypted += decipher.final('utf8');
+    return decrypted;
+  }
+
+  /**
+   * 使用AES加密算法对JSON数据进行加密
+   *
+   * 该方法首先将payload参数序列化为JSON字符串，然后使用指定的密钥进行AES加密
+   * 主要用于在传输敏感信息前，对数据进行加密处理，以确保数据的安全性
+   *
+   * @param payload 任何类型的对象，代表需要加密的原始数据
+   * @param key 字符串类型的密钥，用于AES加密算法
+   *            密钥需要符合AES加密算法的长度要求
+   * @returns 返回加密后的字符串数据
+   *          加密后的数据可以安全地进行网络传输或存储
+   */
+  aesEncryptJson(payload, key) {
+    // 将payload对象序列化为JSON字符串，以便进行加密处理
+    // 使用指定的密钥对序列化后的JSON字符串进行AES加密
+    // 返回加密后的数据，确保数据在传输或存储过程中的安全性
+    return this.aesEncrypt(JSON.stringify(payload), key);
+  }
+
+  /**
+   * 使用AES算法解密给定的文本，并将解密后的结果解析为JSON对象
+   *
+   * @param text 需要解密的加密文本
+   * @param key 解密用的密钥，必须与加密时使用的密钥相同
+   * @returns 返回解密后的JSON对象，类型为泛型T，根据调用时指定的类型解析
+   */
+  aesDecryptJson(text, key) {
+    // 使用指定的密钥对给定的加密数据进行AES解密
+    // 将解密后的数据反序列化为JSON对象，以便后续的处理
+    // 返回解密后的数据，确保数据在传输或存储过程中的安全性
+    return JSON.parse(this.aesDecrypt(text, key));
+  }
+}

package/lib/x.d.ts

@@ -1,5 +1,6 @@
 import { XHandler } from './core/types';
 import { BaseService } from './services/base';
+import './services/crypto';
 import './services/db_value';
 import './services/dispose';
 import './services/emoji';

package/lib/x.js

@@ -2,6 +2,7 @@ import os from 'os';
 import path from 'path';
 import fs from 'fs-extra';
 import { ctxStorage } from "./core/ctx_storage";
+import { CryptoService } from "./services/crypto";
 import { DbValueService } from "./services/db_value";
 import { DisposeService } from "./services/dispose";
 import { EmojiService } from "./services/emoji";
@@ -24,4 +25,4 @@ export const x = {
 fs.ensureDirSync(x.dataDir);
 x.register(new DisposeService({
   disposeOnExit: true
-}), new LogService(), new EmojiService(), new DbValueService());
+}), new LogService(), new EmojiService(), new DbValueService(), new CryptoService());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jayfong/x-server",
-  "version": "2.64.0",
+  "version": "2.66.0",
   "license": "ISC",
   "sideEffects": false,
   "main": "lib/_cjs/index.js",