ph-utils 0.18.0 → 0.19.0

package/lib/src/crypto.js

@@ -0,0 +1,261 @@
+/* eslint-disable no-undef */
+/**
+ * 将原始的二进制数据转换为 Hex String
+ * @param bf 待转换的原始数据
+ * @param upper 是否需要转换为大写
+ * @returns
+ */
+export function bufferToHex(bf, upper = false) {
+    const u8Array = bf instanceof Uint8Array ? bf : new Uint8Array(bf);
+    const hashArray = Array.from(u8Array);
+    return hashArray
+        .map((b) => {
+        let hx = b.toString(16).padStart(2, "0");
+        return upper === true ? hx.toUpperCase() : hx;
+    })
+        .join("");
+}
+/**
+ * 将16进制的数据转换为 UInt8Array
+ * @param data 16进制的数据
+ * @returns
+ */
+function hexToBuffer(data) {
+    const len = data.length / 2;
+    const uint8Array = new Uint8Array(len);
+    for (let i = 0; i < len; i++) {
+        const byteHex = data.substring(i * 2, i * 2 + 2);
+        const byte = parseInt(byteHex.toLocaleLowerCase(), 16);
+        uint8Array[i] = byte;
+    }
+    return uint8Array;
+}
+/**
+ * 将原始数据转换为 Base64 编码
+ * @param bf 待转换的原始数据
+ * @returns
+ */
+function bufferToBase64(bf) {
+    const u8Array = bf instanceof Uint8Array ? bf : new Uint8Array(bf);
+    const hashArray = Array.from(u8Array);
+    return globalThis.btoa(String.fromCharCode.apply(null, hashArray));
+}
+/**
+ * 将 Base64 转换为 UInt8Array 数据
+ * @param data
+ * @returns
+ */
+function base64ToBuffer(data) {
+    return new Uint8Array(globalThis
+        .atob(data)
+        .split("")
+        .map((char) => char.charCodeAt(0)));
+}
+/**
+ * SHA 哈希算法
+ * @param message     待进行 hash 的数据
+ * @param upper       是否转换为大写, 默认为: false
+ * @param algorithm   hash算法, 支持: SHA-1、SHA-256、SHA-384、SHA-512; 默认为: SHA-256
+ * @returns
+ */
+export async function sha(message, upper = false, algorithm = "SHA-256") {
+    let msgBuffer = message;
+    if (typeof message === "string") {
+        msgBuffer = new TextEncoder().encode(message);
+    }
+    const hashBuffer = await globalThis.crypto.subtle.digest(algorithm || "SHA-256", msgBuffer);
+    return bufferToHex(hashBuffer, upper);
+}
+/**
+ * 哈希算法
+ * @param message     待进行 hash 的数据
+ * @param upper       是否转换为大写, 默认为: false
+ * @param algorithm   hash算法, 支持: SHA-1、SHA-256、SHA-384、SHA-512; 默认为: SHA-256
+ * @returns
+ */
+export async function hash(message, upper = false, algorithm = "SHA-256") {
+    return sha(message, upper, algorithm);
+}
+/**
+ * 使用 HMAC 算法计算消息的哈希值
+ * @param message - 需要计算哈希的消息字符串
+ * @param secret - 用于生成 HMAC 的密钥
+ * @param algorithm - HMAC 使用的哈希算法,默认为 "SHA-256"
+ * @param upper - 是否将结果转换为大写,默认为 false
+ * @returns 返回十六进制格式的 HMAC 哈希值
+ */
+export async function hmacHash(message, secret, algorithm = "SHA-256", upper = false) {
+    const encoder = new TextEncoder();
+    const key = await crypto.subtle.importKey("raw", encoder.encode(secret), { name: "HMAC", hash: { name: algorithm } }, false, ["sign"]);
+    const signature = await crypto.subtle.sign("HMAC", key, encoder.encode(message));
+    return bufferToHex(signature, upper);
+}
+function parseRsaKey(pem) {
+    const pemHeader = "-----BEGIN PUBLIC KEY-----";
+    const pemFooter = "-----END PUBLIC KEY-----";
+    if (pem.indexOf(pemHeader) !== -1 && pem.indexOf(pemFooter) !== -1) {
+        pem = pem.substring(pemHeader.length, pem.indexOf(pemFooter)).trim();
+    }
+    return pem;
+}
+/**
+ * 导入上下文密钥
+ * @param key           导入的密钥
+ * @param algorithmName 算法名称
+ * @param usages        该密钥可以用于哪些函数使用
+ * @returns
+ */
+// eslint-disable-next-line no-undef
+async function importKey(key, algorithmName, usages, encoding = "hex") {
+    let name = "AES-CBC";
+    if (algorithmName == null) {
+        name = "AES-CBC";
+    }
+    else {
+        if (algorithmName.toUpperCase() === "AES") {
+            name = "AES-CBC";
+        }
+        else if (algorithmName.toUpperCase() === "RSA") {
+            name = "RSA-OAEP";
+        }
+    }
+    name = name.toUpperCase();
+    if (usages == null || usages.length === 0) {
+        usages = ["encrypt"];
+    }
+    let format = "raw";
+    let algorithm = { name };
+    if (name.includes("RSA")) {
+        format = "spki";
+        algorithm.hash = { name: "SHA-256" };
+        key = parseRsaKey(key);
+    }
+    const keyBuf = encoding === "base64" ? base64ToBuffer(key) : hexToBuffer(key);
+    // importKey时传 false 表明该密钥不能被导出
+    return Promise.all([
+        globalThis.crypto.subtle.importKey(format, keyBuf, algorithm, false, usages),
+        Promise.resolve({ name }),
+    ]);
+}
+/**
+ * 加密
+ * @param algorithm  算法参数, 算法名称、向量等
+ * @param key        算法密钥
+ * @param message    待加密的数据
+ * @param encode     解密后返回数据格式
+ * @returns
+ */
+async function encrypt(algorithm, key, message, encode = "hex") {
+    if (typeof message === "string") {
+        message = new TextEncoder().encode(message);
+    }
+    const encrypted = await globalThis.crypto.subtle.encrypt(algorithm, key, message);
+    if (encode === "hex") {
+        return bufferToHex(encrypted);
+    }
+    else if (encode === "hexUpper") {
+        return bufferToHex(encrypted, true);
+    }
+    else if (encode === "base64") {
+        return bufferToBase64(encrypted);
+    }
+    else {
+        return encrypted;
+    }
+}
+/**
+ * 数据解密
+ * @param algorithm 解密算法
+ * @param key       解密密钥
+ * @param message   加密后的数据
+ * @returns
+ */
+async function decrypt(algorithm, key, message) {
+    const decrypted = await globalThis.crypto.subtle.decrypt(algorithm, key, message);
+    return new TextDecoder("utf-8").decode(decrypted);
+}
+/**
+ * AES 加密
+ * @param message 待加密的数据
+ * @param key 加解密密钥
+ * @param encode 加密后的数据转换的形式, hex - 转换为16进制字符串, hexUpper - 转换为16进制且大写, base64 - 转换为 base64 形式
+ * @param iv 加解密向量
+ * @returns [加密数据,向量]
+ */
+export async function aesEncrypt(message, key, encode = "hex", iv = null) {
+    let ciphertext = "";
+    let resIv = "";
+    // 导入密钥
+    const [cryptoKey, algorithm] = await importKey(key, "aes", ["encrypt"]);
+    if (iv == null) {
+        iv = globalThis.crypto.getRandomValues(new Uint8Array(16));
+    }
+    else if (typeof iv === "string") {
+        iv = hexToBuffer(iv);
+    }
+    const encodeData = await encrypt({ ...algorithm, iv: iv }, cryptoKey, message, encode);
+    ciphertext = encodeData;
+    resIv = bufferToHex(iv);
+    return { ciphertext, iv: resIv, key };
+}
+/**
+ * 根据加密后的数据类型使用对应函数最终转换为 UInt8Array
+ * @param message 原始加密后的数据
+ * @param type    类型: hex | base64
+ * @returns
+ */
+function parseEncryptData(message, type) {
+    let input;
+    if (typeof message === "string") {
+        if (type === "hex" || type === "hexUpper") {
+            input = hexToBuffer(message);
+        }
+        else {
+            input = base64ToBuffer(message);
+        }
+    }
+    else {
+        input = message;
+    }
+    return input;
+}
+/**
+ * AES 解密
+ * @param message 加密后的数据
+ * @param key     解密密钥
+ * @param iv      向量
+ * @param encode  加密后数据的形式: hex | base64
+ * @returns
+ */
+export async function aesDecrypt(message, key, iv, encode = "hex") {
+    // 导入密钥
+    const [cryptoKey, algorithm] = await importKey(key, "aes", ["decrypt"]);
+    const input = parseEncryptData(message, encode);
+    return await decrypt({ ...algorithm, iv: hexToBuffer(iv) }, cryptoKey, input);
+}
+/**
+ * RSA 加密
+ * @param key     公钥
+ * @param message 待加密数据
+ * @param encode  返回类型
+ * @returns
+ */
+export async function rsaEncrypt(message, publicKey, encode = "hex") {
+    // 导入密钥
+    const [cryptoKey, algorithm] = await importKey(publicKey, "rsa", ["encrypt"], "base64");
+    return await encrypt(algorithm, cryptoKey, message, encode);
+}
+/**
+ * RSA 解密
+ * @param key     私钥, 根据私钥解密
+ * @param message 加密后的数据
+ * @param encode  加密后的数据形式
+ * @returns
+ */
+export async function rsaDecrypt(privateKey, message, encode = "hex") {
+    // 导入密钥
+    const [cryptoKey, algorithm] = await importKey(privateKey, "rsa", [
+        "decrypt",
+    ]);
+    return await decrypt({ ...algorithm }, cryptoKey, parseEncryptData(message, encode));
+}

package/lib/src/crypto_node.d.ts

@@ -0,0 +1,61 @@
+type HashAlgorithmName = "md5" | SHAHashAlgorithmName;
+type SHAHashAlgorithmName = "sha1" | "sha256" | "sha512";
+/**
+ * 进行 md5|sha1|sha256 数据摘要签名
+ * @param d 待加密的数据
+ * @param algorithm 签名算法, md5、sha1、sha256. Defaults to "sha256".
+ * @param upper 返回的结果是否需要大写. Defaults to False.
+ */
+export declare function hashDigest(d: string, algorithm?: HashAlgorithmName, upper?: boolean): string;
+/**
+ * 进行 md5|sha1|sha256 数据摘要签名
+ * @param d 待加密的数据
+ * @param algorithm 签名算法, md5、sha1、sha256. Defaults to "sha256".
+ * @param upper 返回的结果是否需要大写. Defaults to False.
+ */
+export declare function hash(d: string, algorithm?: HashAlgorithmName, upper?: boolean): string;
+/**
+ * 使用 HMAC 算法对消息进行哈希处理
+ * @param message 待处理的消息
+ * @param key 用于 HMAC 算法的密钥
+ * @param algorithm 哈希算法，可选值为 "sha1"、"sha256" 或 "sha512"，默认为 "sha256"
+ * @param upper 返回的结果是否需要大写，默认为 false
+ * @returns 经过 HMAC 哈希处理后的字符串
+ */
+export declare function hmacHash(message: string, key: string, algorithm?: SHAHashAlgorithmName, upper?: boolean): string;
+/**
+ * 生成 RSA 签名密钥对
+ * @returns: [公钥, 私钥]
+ */
+export declare function keyPair(): Promise<[string, string]>;
+/**
+ * AES 加密
+ * @param key   加密密钥
+ * @param input 待加密的数据
+ * @param upper 是否转换为大写
+ * @returns [加密数据, 向量]
+ */
+export declare function aesEncrypt(key: string, input: string, upper?: boolean): [string, string];
+/**
+ * AES 解密
+ * @param input 加密后的数据
+ * @param key   密钥
+ * @param iv    向量
+ * @returns
+ */
+export declare function aesDecrypt(input: string, key: string | Buffer, iv?: string | Buffer, algorithm?: string): string;
+/**
+ * RSA 公钥加密
+ * @param input 待加密字符串
+ * @param publicKey 公钥
+ * @returns
+ */
+export declare function rsaEncrypt(input: string, publicKey: string): string;
+/**
+ * RSA 解密
+ * @param encrtypData RSA加密后的数据
+ * @param privateKey  私钥
+ * @returns
+ */
+export declare function rsaDecrypt(encrtypData: string, privateKey: string): string;
+export {};

package/lib/src/crypto_node.js

@@ -0,0 +1,133 @@
+import { createHash, createCipheriv, randomBytes, generateKeyPair, createDecipheriv, privateDecrypt, publicEncrypt, createHmac, } from "node:crypto";
+/**
+ * 进行 md5|sha1|sha256 数据摘要签名
+ * @param d 待加密的数据
+ * @param algorithm 签名算法, md5、sha1、sha256. Defaults to "sha256".
+ * @param upper 返回的结果是否需要大写. Defaults to False.
+ */
+export function hashDigest(d, algorithm = "sha256", upper = false) {
+    const hashed = createHash(algorithm).update(d).digest("hex");
+    return upper ? hashed.toUpperCase() : hashed;
+}
+/**
+ * 进行 md5|sha1|sha256 数据摘要签名
+ * @param d 待加密的数据
+ * @param algorithm 签名算法, md5、sha1、sha256. Defaults to "sha256".
+ * @param upper 返回的结果是否需要大写. Defaults to False.
+ */
+export function hash(d, algorithm = "sha256", upper = false) {
+    return hashDigest(d, algorithm, upper);
+}
+/**
+ * 使用 HMAC 算法对消息进行哈希处理
+ * @param message 待处理的消息
+ * @param key 用于 HMAC 算法的密钥
+ * @param algorithm 哈希算法，可选值为 "sha1"、"sha256" 或 "sha512"，默认为 "sha256"
+ * @param upper 返回的结果是否需要大写，默认为 false
+ * @returns 经过 HMAC 哈希处理后的字符串
+ */
+export function hmacHash(message, key, algorithm = "sha256", upper = false) {
+    const hashed = createHmac(algorithm, key).update(message).digest("hex");
+    return upper ? hashed.toUpperCase() : hashed;
+}
+/**
+ * 生成 RSA 签名密钥对
+ * @returns: [公钥, 私钥]
+ */
+export async function keyPair() {
+    return new Promise((resolve, reject) => {
+        generateKeyPair("rsa", {
+            modulusLength: 2048,
+            publicKeyEncoding: {
+                type: "spki",
+                format: "pem",
+            },
+            privateKeyEncoding: {
+                type: "pkcs8",
+                format: "pem",
+            },
+        }, (err, publicKey, privateKey) => {
+            if (err == null) {
+                resolve([publicKey, privateKey]);
+            }
+            else {
+                reject(err);
+            }
+        });
+    });
+}
+/**
+ * AES 加密
+ * @param key   加密密钥
+ * @param input 待加密的数据
+ * @param upper 是否转换为大写
+ * @returns [加密数据, 向量]
+ */
+export function aesEncrypt(key, input, upper = false) {
+    const iv = randomBytes(16);
+    const cipher = createCipheriv("aes-256-cbc", Buffer.from(key, "hex"), iv);
+    let encryptedData = cipher.update(input, "utf-8", "hex");
+    encryptedData += cipher.final("hex");
+    return [
+        upper === true ? encryptedData.toUpperCase() : encryptedData,
+        iv.toString("hex"),
+    ];
+}
+function aesAlgorithm(key) {
+    if (key.startsWith("aes-"))
+        return key;
+    let prefix = "aes-";
+    // 如果 key 不是以数字开头，则加上数字，例如：128，256 等
+    if (!/^\d/.test(key)) {
+        prefix += "256-";
+    }
+    return `${prefix}${key}`;
+}
+/**
+ * AES 解密
+ * @param input 加密后的数据
+ * @param key   密钥
+ * @param iv    向量
+ * @returns
+ */
+export function aesDecrypt(input, key, iv, algorithm = "aes-256-cbc") {
+    let ivBuffer = null;
+    if (iv && !Buffer.isBuffer(iv)) {
+        ivBuffer = Buffer.from(iv, "hex");
+    }
+    let keyBuffer;
+    if (Buffer.isBuffer(key)) {
+        keyBuffer = key;
+    }
+    else {
+        keyBuffer = Buffer.from(key, "hex");
+    }
+    const cipher = createDecipheriv(aesAlgorithm(algorithm), keyBuffer, ivBuffer);
+    let decryptedData = cipher.update(input, "hex", "utf-8");
+    decryptedData += cipher.final("utf-8");
+    return decryptedData;
+}
+/**
+ * RSA 公钥加密
+ * @param input 待加密字符串
+ * @param publicKey 公钥
+ * @returns
+ */
+export function rsaEncrypt(input, publicKey) {
+    return publicEncrypt({
+        key: publicKey,
+        oaepHash: "sha256",
+    }, Buffer.from(input)).toString("base64");
+}
+/**
+ * RSA 解密
+ * @param encrtypData RSA加密后的数据
+ * @param privateKey  私钥
+ * @returns
+ */
+export function rsaDecrypt(encrtypData, privateKey) {
+    return privateDecrypt({
+        key: privateKey,
+        oaepHash: "sha256",
+    }, Buffer.from(encrtypData, "base64")).toString("utf-8");
+}

package/lib/src/date.d.ts

@@ -0,0 +1,66 @@
+/**
+ * 将日期格式化为指定形式的字符串
+ * @param date      日期
+ * @param pattern   格式化字符串 yyyy - 年, mm - 月, dd - 日, HH - 小时(24时制), MM - 分钟, ss - 秒, S - 毫秒, 默认: yyyy-mm-dd HH:MM:ss
+ */
+export declare function format(date?: Date | string | number | null, pattern?: string): string;
+/**
+ * 将指定的参数解析为日期对象(Date)
+ * 参考 dayjs 实现, 也可以参考 https://github.com/nomiddlename/date-format
+ * @param date 待解析的日期参数
+ */
+export declare function parse(date?: Date | string | number | null): Date;
+/**
+ * 设置日期的开始或者结束的点
+ * @param date 日期，能够被 parse 解析的日期
+ * @param unit 单位，Date[D]、Minute[M], 默认为 Date
+ * @param isEnd true则为 endOf
+ */
+export declare function dateOf(date?: Date | string | number | null, unit?: string, isEnd?: boolean): Date;
+/**
+ * 设置日期的开始的点
+ * @param date 日期，能够被 parse 解析的日期
+ * @param unit 单位，Date[D]、Minute[M], 默认为 Date
+ * @returns
+ */
+export declare function startOf(date?: Date | string | number | null, unit?: string): Date;
+/**
+ * 设置日期的结束点
+ * @param date 日期，能够被 parse 解析的日期
+ * @param unit 单位，Date[D]、Minute[M], 默认为 Date
+ * @returns
+ */
+export declare function endOf(date?: Date | string | number | null, unit?: string): Date;
+/**
+ * 获取时间戳
+ * @param ctime 时间
+ * @param pre 精度, s - 精确到秒, ms - 精确到毫秒, 默认: s
+ * @returns
+ */
+export declare function timestamp(ctime?: Date | string | number, pre?: "s" | "ms"): number;
+/**
+ * 日期加上指定时间后的日期
+ * @param date 指定的日期
+ * @param num  需要添加的数字, 如果这个参数传递一个小于0的数字，则就是日期减去相应的数字
+ * @param unit 需要添加的单位，date、month、year、hours、minute、second
+ *
+ * 查阅文档: {@link https://gitee.com/towardly/ph/wikis/utils/date ph-utils}
+ *
+ * @example <caption>1. 分钟加1并格式化显示时间</caption>
+ *
+ * add(new Date(), 1, 'minute', 'HHMMss')
+ */
+export declare function add(date: Date | string | number | null, num: number, unit: string): Date;
+/**
+ * 日期加上指定时间后的日期
+ * @param date    指定的日期, 传递为 null ，则表示为当前日期
+ * @param num     需要添加的数字, 如果这个参数传递一个小于0的数字，则就是日期减去相应的数字
+ * @param unit    需要添加的单位，date - 加减天数
+ * @param fmt     如果传递了格式化的单位，则返回格式化后的日期, 格式化字符串 yyyy - 年, mm - 月, dd - 日, HH - 小时, MM - 分钟, ss - 秒
+ *
+ * #### 1. 前一天的日期字符串形式
+ * ```javascript
+ * add(new Date(), -1, 'Date', 'yyyy-mm-dd')
+ * ```
+ */
+export declare function add(date: Date | string | number | null, num: number, unit: string, fmt: string): string;