@ivujs/i-utils 1.1.18 → 2.1.0

package/dist/es/crypto/sm3/sm3.mjs

@@ -0,0 +1,197 @@
+/**
+ * SM3 纯函数式实现（无类、无实例，闭包隔离状态）
+ */
+// 全局常量（只读，无状态）
+const BLOCK_LENGTH = 64;
+const IPAD = new Uint8Array(BLOCK_LENGTH).fill(0x36);
+const OPAD = new Uint8Array(BLOCK_LENGTH).fill(0x5c);
+const IV = new Uint32Array([
+    0x7380166f, 0x4914b2b9, 0x172442d7, 0xda8a0600, 0xa96f30bc, 0x163138aa, 0xe38dee4d, 0xb0fb0e4e,
+]);
+// 纯函数：循环左移
+function rotl(x, n) {
+    const s = n & 31;
+    return (x << s) | (x >>> (32 - s));
+}
+// 纯函数：字节数组异或
+function xor(x, y) {
+    const result = [];
+    for (let i = x.length - 1; i >= 0; i--) {
+        result[i] = (x[i] ^ y[i]) & 0xff;
+    }
+    return result;
+}
+// 纯函数：置换函数 P0
+function P0(X) {
+    return X ^ rotl(X, 9) ^ rotl(X, 17);
+}
+// 纯函数：置换函数 P1
+function P1(X) {
+    return X ^ rotl(X, 15) ^ rotl(X, 23);
+}
+// 纯函数：补全16进制字符串
+function leftPad(input, num) {
+    if (input.length >= num)
+        return input;
+    return new Array(num - input.length + 1).join("0") + input;
+}
+// 纯函数：字节数组转16进制
+function arrayToHex(arr) {
+    return arr
+        .map((item) => {
+        item = item.toString(16);
+        return item.length === 1 ? "0" + item : item;
+    })
+        .join("");
+}
+// 纯函数：16进制转字节数组
+function hexToArray(hexStr) {
+    const words = [];
+    let hexStrLength = hexStr.length;
+    if (hexStrLength % 2 !== 0) {
+        hexStr = leftPad(hexStr, hexStrLength + 1);
+    }
+    hexStrLength = hexStr.length;
+    for (let i = 0; i < hexStrLength; i += 2) {
+        words.push(parseInt(hexStr.substr(i, 2), 16));
+    }
+    return words;
+}
+// 纯函数：UTF8转字节数组
+function utf8ToArray(str) {
+    const arr = [];
+    for (let i = 0, len = str.length; i < len; i++) {
+        const point = str.codePointAt(i);
+        if (point <= 0x007f) {
+            arr.push(point);
+        }
+        else if (point <= 0x07ff) {
+            arr.push(0xc0 | (point >>> 6));
+            arr.push(0x80 | (point & 0x3f));
+        }
+        else if (point <= 0xd7ff || (point >= 0xe000 && point <= 0xffff)) {
+            arr.push(0xe0 | (point >>> 12));
+            arr.push(0x80 | ((point >>> 6) & 0x3f));
+            arr.push(0x80 | (point & 0x3f));
+        }
+        else if (point >= 0x010000 && point <= 0x10ffff) {
+            i++;
+            arr.push(0xf0 | ((point >>> 18) & 0x1c));
+            arr.push(0x80 | ((point >>> 12) & 0x3f));
+            arr.push(0x80 | ((point >>> 6) & 0x3f));
+            arr.push(0x80 | (point & 0x3f));
+        }
+        else {
+            arr.push(point);
+            throw new Error("input is not supported");
+        }
+    }
+    return arr;
+}
+// 核心纯函数：SM3哈希计算（闭包隔离状态）
+function sm3Core(array) {
+    // 每次调用都创建全新的局部状态（隔离关键）
+    let len = array.length * 8;
+    let k = len % 512;
+    k = k >= 448 ? 512 - (k % 448) - 1 : 448 - k - 1;
+    const kArr = new Array((k - 7) / 8).fill(0);
+    const lenArr = new Array(8).fill(0);
+    let lenBin = len.toString(2);
+    for (let i = 7; i >= 0; i--) {
+        if (lenBin.length > 8) {
+            const start = lenBin.length - 8;
+            lenArr[i] = parseInt(lenBin.substr(start), 2);
+            lenBin = lenBin.substr(0, start);
+        }
+        else if (lenBin.length > 0) {
+            lenArr[i] = parseInt(lenBin, 2);
+            lenBin = "";
+        }
+    }
+    const m = new Uint8Array([...array, 0x80, ...kArr, ...lenArr]);
+    const dataView = new DataView(m.buffer, 0);
+    const n = m.length / 64;
+    const V = new Uint32Array(IV); // 全新初始向量（每次调用重新创建）
+    const W = new Uint32Array(68); // 全新消息扩展数组
+    const M = new Uint32Array(64); // 全新W'数组
+    // 以下计算逻辑和原代码一致，仅操作局部变量
+    for (let i = 0; i < n; i++) {
+        W.fill(0);
+        M.fill(0);
+        const start = 16 * i;
+        for (let j = 0; j < 16; j++) {
+            W[j] = dataView.getUint32((start + j) * 4, false);
+        }
+        for (let j = 16; j < 68; j++) {
+            W[j] = P1(W[j - 16] ^ W[j - 9] ^ rotl(W[j - 3], 15)) ^ rotl(W[j - 13], 7) ^ W[j - 6];
+        }
+        for (let j = 0; j < 64; j++) {
+            M[j] = W[j] ^ W[j + 4];
+        }
+        const T1 = 0x79cc4519;
+        const T2 = 0x7a879d8a;
+        let A = V[0], B = V[1], C = V[2], D = V[3];
+        let E = V[4], F = V[5], G = V[6], H = V[7];
+        let SS1, SS2, TT1, TT2, T;
+        for (let j = 0; j < 64; j++) {
+            T = j <= 15 ? T1 : T2;
+            SS1 = rotl((rotl(A, 12) + E + rotl(T, j)) & 0xffffffff, 7);
+            SS2 = SS1 ^ rotl(A, 12);
+            const FFj = j <= 15 ? A ^ B ^ C : (A & B) | (A & C) | (B & C);
+            const GGj = j <= 15 ? E ^ F ^ G : (E & F) | (~E & G);
+            TT1 = (FFj + D + SS2 + M[j]) & 0xffffffff;
+            TT2 = (GGj + H + SS1 + W[j]) & 0xffffffff;
+            D = C;
+            C = rotl(B, 9);
+            B = A;
+            A = TT1;
+            H = G;
+            G = rotl(F, 19);
+            F = E;
+            E = P0(TT2);
+        }
+        V[0] ^= A;
+        V[1] ^= B;
+        V[2] ^= C;
+        V[3] ^= D;
+        V[4] ^= E;
+        V[5] ^= F;
+        V[6] ^= G;
+        V[7] ^= H;
+    }
+    const result = [];
+    for (let i = 0; i < V.length; i++) {
+        result.push((V[i] & 0xff000000) >>> 24, (V[i] & 0xff0000) >>> 16, (V[i] & 0xff00) >>> 8, V[i] & 0xff);
+    }
+    return result;
+}
+// 纯函数：HMAC-SM3计算
+function encryptHmac(input, key) {
+    let processedKey = key.length > BLOCK_LENGTH ? sm3Core(key) : [...key];
+    while (processedKey.length < BLOCK_LENGTH) {
+        processedKey.push(0);
+    }
+    const iPadKey = xor(processedKey, IPAD);
+    const oPadKey = xor(processedKey, OPAD);
+    const innerHash = sm3Core([...iPadKey, ...input]);
+    return sm3Core([...oPadKey, ...innerHash]);
+}
+// 对外暴露的核心函数（兼容原调用方式）
+function encrypt(input, key) {
+    const inputArr = typeof input === "string" ? utf8ToArray(input) : Array.prototype.slice.call(input);
+    if (!key) {
+        const hashArr = sm3Core(inputArr);
+        return arrayToHex(hashArr);
+    }
+    else {
+        const keyArr = typeof key === "string"
+            ? /^[0-9a-fA-F]+$/.test(key)
+                ? hexToArray(key)
+                : utf8ToArray(key)
+            : Array.prototype.slice.call(key);
+        const hmacArr = encryptHmac(inputArr, keyArr);
+        return arrayToHex(hmacArr);
+    }
+}
+
+export { encrypt, encryptHmac as encrypt_hmac };

package/dist/es/crypto/sm4/index.d.ts

@@ -0,0 +1,56 @@
+import * as sm4 from "./sm4.js";
+/**
+ * sm4传参和返回的类型，不管是传参还是返回值固定是这几个
+ */
+export type SM4DataType = string | Uint8Array | ArrayBuffer | number[];
+/**
+ * sm4通用配置
+ */
+export interface SM4Options {
+    mode?: keyof typeof sm4.MODE;
+    iv?: SM4DataType;
+    padding?: "pkcs#7";
+    output?: keyof typeof sm4.OUTPUT;
+}
+/**
+ * sm4 加密
+ * @param {string} str 字符串
+ * @param {string} key 秘钥
+ * @param {Object} options 配置
+ * @returns {string} 加密后的字符串
+ */
+export declare function sm4Encrypt(str: string, key: SM4DataType, options?: SM4Options): SM4DataType;
+/**
+ * sm4 解密
+ * @param {string} str 字符串
+ * @param {string} key 秘钥
+ * @param {Object} options 配置
+ * @returns {string} 解密后的数据
+ */
+export declare function sm4Decrypt(str: string, key: SM4DataType, options?: SM4Options): SM4DataType;
+/**
+ * 生成sm4的key
+ * @param {string} inputFormat 输入类型 可以任意字符串，其中固定的uint8array、array、hex这3个字符串，会对应生成类型数据
+ * @returns {SM4DataType} 生成的key
+ */
+export declare const generateSM4Key: (inputFormat?: string) => SM4DataType;
+/**
+ * 生成sm4的iv
+ * @param {string} inputFormat 输入类型 可以任意字符串，其中固定的uint8array、array、hex这3个字符串，会对应生成类型数据
+ * @returns {SM4DataType} 生成的iv
+ */
+export declare const generateSM4Iv: (inputFormat?: string) => SM4DataType;
+export declare const SM4: {
+    MODE: {
+        ECB: string;
+        CBC: string;
+    };
+    PADDING: string;
+    OUTPUT: {
+        HEX: string;
+        UTF8: string;
+        ARRAY: string;
+        UINT8ARRAY: string;
+        ARRAYBUFFER: string;
+    };
+};

package/dist/es/crypto/sm4/index.mjs

@@ -0,0 +1,95 @@
+import { generateKey, generateIv, OUTPUT, PADDING, MODE, encrypt, decrypt } from './sm4.mjs';
+
+/**
+ * sm4 加密
+ * @param {string} str 字符串
+ * @param {string} key 秘钥
+ * @param {Object} options 配置
+ * @returns {string} 加密后的字符串
+ */
+function sm4Encrypt(str, key, options) {
+    _validateSM4Options(options, "encrypt");
+    return encrypt(str, key, options);
+}
+/**
+ * sm4 解密
+ * @param {string} str 字符串
+ * @param {string} key 秘钥
+ * @param {Object} options 配置
+ * @returns {string} 解密后的数据
+ */
+function sm4Decrypt(str, key, options) {
+    _validateSM4Options(options, "decrypt");
+    return decrypt(str, key, options);
+}
+/**
+ * 生成sm4的key
+ * @param {string} inputFormat 输入类型 可以任意字符串，其中固定的uint8array、array、hex这3个字符串，会对应生成类型数据
+ * @returns {SM4DataType} 生成的key
+ */
+const generateSM4Key = generateKey;
+/**
+ * 生成sm4的iv
+ * @param {string} inputFormat 输入类型 可以任意字符串，其中固定的uint8array、array、hex这3个字符串，会对应生成类型数据
+ * @returns {SM4DataType} 生成的iv
+ */
+const generateSM4Iv = generateIv;
+/**
+ * 校验SM4配置参数的合法性
+ * @param options 配置项
+ * @param operation 操作类型（encrypt/decrypt）
+ */
+function _validateSM4Options(options = {}, operation) {
+    const { mode = MODE.ECB, iv } = options;
+    // 1. 校验模式是否合法
+    const validModes = Object.values(MODE);
+    if (!validModes.includes(mode)) {
+        throw new Error(`sm4${operation} 方法错误：不支持的加密模式 "${mode}"，仅支持 ${validModes.join("/")}`);
+    }
+    // 2. CBC模式必须传IV
+    if (mode === MODE.CBC && !iv) {
+        throw new Error(`sm4${operation} 方法错误：CBC 模式必须传入 IV 初始向量`);
+    }
+    // 3. ECB模式禁止传IV（避免误用）
+    if (mode === MODE.ECB && iv !== undefined) {
+        throw new Error(`sm4${operation} 方法错误：ECB 模式不需要传入 IV，请勿传递iv参数`);
+    }
+    // 4. 校验IV长度（如果传了IV）
+    if (iv) {
+        let ivLength;
+        if (typeof iv === "string") {
+            // hex字符串：16字节对应32位hex
+            ivLength = iv.length === 32 ? 16 : iv.length;
+        }
+        else if (iv instanceof ArrayBuffer) {
+            ivLength = iv.byteLength;
+        }
+        else if (iv instanceof Uint8Array) {
+            ivLength = iv.length;
+        }
+        else if (Array.isArray(iv)) {
+            ivLength = iv.length;
+        }
+        else {
+            ivLength = 0;
+        }
+        if (ivLength !== 16) {
+            throw new Error(`SM4${operation}错误：IV 长度必须为 16 字节，当前长度为 ${ivLength}`);
+        }
+    }
+    // 5. 校验填充模式（仅允许pkcs#7）
+    if (options.padding && options.padding !== String(PADDING)) {
+        throw new Error(`SM4${operation}错误：仅支持 pkcs#7 填充模式，当前传入 ${String(options.padding)}`);
+    }
+}
+// sm4的配置
+const SM4 = {
+    // sm4的模式
+    MODE: MODE,
+    // sm4的填充
+    PADDING: PADDING,
+    // sm4的输出
+    OUTPUT: OUTPUT,
+};
+
+export { SM4, generateSM4Iv, generateSM4Key, sm4Decrypt, sm4Encrypt };

package/dist/es/crypto/sm4/sm4.d.ts

@@ -0,0 +1,48 @@
+/**
+ * 生成 SM4 CBC 模式专用的安全随机 IV（16字节）
+ * @param {string} [outputFormat=SM4_OUTPUT_HEX] - 输出格式：hex/uint8array/array/arraybuffer
+ * @returns {string|Uint8Array|Array|ArrayBuffer} 随机IV
+ */
+export function generateIv(outputFormat?: string): string | Uint8Array | any[] | ArrayBuffer;
+/**
+ * 生成 SM4 标准密钥（16字节/32位16进制字符串）
+ * @param {string} [outputFormat=SM4_OUTPUT_HEX] - 输出格式：hex/uint8array/array/arraybuffer
+ * @returns {string|Uint8Array|number[]|ArrayBuffer} 16字节SM4密钥
+ */
+export function generateKey(outputFormat?: string): string | Uint8Array | number[] | ArrayBuffer;
+/**
+ * SM4加密
+ * @param {string|Array|Uint8Array|ArrayBuffer} input - 输入数据（字符串/字节）
+ * @param {string|Array|Uint8Array|ArrayBuffer} key - 16字节密钥
+ * @param {Object} [options] - 选项
+ * @returns {string|Array|Uint8Array|ArrayBuffer} 加密结果
+ */
+export function encrypt(input: string | any[] | Uint8Array | ArrayBuffer, key: string | any[] | Uint8Array | ArrayBuffer, options?: Object): string | any[] | Uint8Array | ArrayBuffer;
+/**
+ * SM4解密
+ * @param {string|Array|Uint8Array|ArrayBuffer} input - 加密数据（16进制字符串/字节）
+ * @param {string|Array|Uint8Array|ArrayBuffer} key - 16字节密钥
+ * @param {Object} [options] - 选项
+ * @returns {string|Array|Uint8Array|ArrayBuffer} 解密结果
+ */
+export function decrypt(input: string | any[] | Uint8Array | ArrayBuffer, key: string | any[] | Uint8Array | ArrayBuffer, options?: Object): string | any[] | Uint8Array | ArrayBuffer;
+export namespace MODE {
+    export { SM4_MODE_ECB as ECB };
+    export { SM4_MODE_CBC as CBC };
+}
+export const PADDING: "pkcs#7";
+export namespace OUTPUT {
+    export { SM4_OUTPUT_HEX as HEX };
+    export { SM4_OUTPUT_UTF8 as UTF8 };
+    export { SM4_OUTPUT_ARRAY as ARRAY };
+    export { SM4_OUTPUT_UINT8ARRAY as UINT8ARRAY };
+    export { SM4_OUTPUT_ARRAYBUFFER as ARRAYBUFFER };
+}
+declare const SM4_MODE_ECB: "ecb";
+declare const SM4_MODE_CBC: "cbc";
+declare const SM4_OUTPUT_HEX: "hex";
+declare const SM4_OUTPUT_UTF8: "utf8";
+declare const SM4_OUTPUT_ARRAY: "array";
+declare const SM4_OUTPUT_UINT8ARRAY: "uint8array";
+declare const SM4_OUTPUT_ARRAYBUFFER: "arraybuffer";
+export {};