minigame-std
Version:
Cross-platform standard library for WeChat minigame and web browsers with unified APIs for crypto, fs, fetch, storage, and more.
735 lines (734 loc) • 23.7 kB
JavaScript
import { Err, Lazy, Ok, tryAsyncResult, tryResult } from "happy-rusty";
import { ByteStringBuffer, importPublicKey, sha1 as sha1$1, sha256 as sha256$1, sha384 as sha384$1, sha512 as sha512$1 } from "rsa-oaep-encryption";
import { decodeByteString, decodeUtf8, encodeBase64, encodeByteString, encodeHex, encodeUtf8 } from "./codec.mjs";
import { bufferSourceToBytes, validatePositiveInteger } from "./_internal.mjs";
import { asyncIOResultify } from "./utils.mjs";
//#region \0rolldown/runtime.js
var __defProp = Object.defineProperty;
var __exportAll = (all, no_symbols) => {
let target = {};
for (var name in all) __defProp(target, name, {
get: all[name],
enumerable: true
});
if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
return target;
};
//#endregion
//#region src/macros/env.ts
/**
* 如果在小游戏环境中返回 true，否则返回 false。
*/
const IS_MINA = __MINIGAME_STD_MINA__;
//#endregion
//#region src/std/crypto/hmac/hmac.ts
/**
* @internal
* 基于哈希的消息认证码实现。需要一个消息摘要对象，
* 例如可以从 forge.md.sha1 或 forge.md.md5 获取。
*
* @author Dave Longley
*
* Copyright (c) 2010-2012 Digital Bazaar, Inc. All rights reserved.
*/
/**
* 创建一个使用指定消息摘要对象的 HMAC 对象。
*
* @param sha - SHA 哈希算法。
* @param key - 密钥，可以是字符串或 BufferSource。
* @param data - 需要计算 HMAC 的数据，可以是字符串或 BufferSource。
* @returns HMAC 计算结果的十六进制字符串。
*/
function createHMAC$1(sha, key, data) {
return tryAsyncResult(() => {
let shaAlgorithmCreator;
switch (sha) {
case "SHA-1":
shaAlgorithmCreator = sha1$1;
break;
case "SHA-256":
shaAlgorithmCreator = sha256$1;
break;
case "SHA-384":
shaAlgorithmCreator = sha384$1;
break;
case "SHA-512":
shaAlgorithmCreator = sha512$1;
break;
}
const shaAlgorithm = shaAlgorithmCreator.create();
let keyBuffer = new ByteStringBuffer(encodeByteString(key));
let keylen = keyBuffer.length();
if (keylen > shaAlgorithm.blockLength) {
shaAlgorithm.start();
shaAlgorithm.update(keyBuffer.bytes());
keyBuffer = shaAlgorithm.digest();
}
const ipadding = new ByteStringBuffer();
const opadding = new ByteStringBuffer();
keylen = keyBuffer.length();
for (let i = 0; i < keylen; ++i) {
const tmp = keyBuffer.at(i);
ipadding.putByte(54 ^ tmp);
opadding.putByte(92 ^ tmp);
}
if (keylen < shaAlgorithm.blockLength) {
const tmp = shaAlgorithm.blockLength - keylen;
for (let i = 0; i < tmp; ++i) {
ipadding.putByte(54);
opadding.putByte(92);
}
}
shaAlgorithm.start();
shaAlgorithm.update(ipadding.bytes());
shaAlgorithm.update(encodeByteString(data));
const inner = shaAlgorithm.digest().bytes();
shaAlgorithm.start();
shaAlgorithm.update(opadding.bytes());
shaAlgorithm.update(inner);
return shaAlgorithm.digest().toHex();
});
}
//#endregion
//#region src/std/codec/helpers.ts
/**
* 将 DataSource 转换为 Uint8Array。
* - 字符串：先 UTF-8 编码
* - BufferSource：转换为 Uint8Array
* @param data - 需要转换的数据。
* @returns 转换后的 `Uint8Array`。
*/
function dataSourceToBytes(data) {
return typeof data === "string" ? encodeUtf8(data) : bufferSourceToBytes(data);
}
//#endregion
//#region src/std/crypto/hmac/web_hmac.ts
/**
* @internal
* Web 平台的 HMAC 实现。
*/
/**
* 使用 Web Crypto API 创建 HMAC。
* @param hash - SHA 哈希算法。
* @param key - 密钥，可以是字符串或 BufferSource。
* @param data - 需要计算 HMAC 的数据，可以是字符串或 BufferSource。
* @returns HMAC 计算结果的十六进制字符串。
*/
function createHMAC(hash, key, data) {
return tryAsyncResult(async () => {
const encodedKey = dataSourceToBytes(key);
const encodedData = dataSourceToBytes(data);
const cryptoKey = await crypto.subtle.importKey("raw", encodedKey, {
name: "HMAC",
hash: { name: hash }
}, false, ["sign"]);
return encodeHex(await crypto.subtle.sign("HMAC", cryptoKey, encodedData));
});
}
//#endregion
//#region src/std/crypto/hmac/mod.ts
/**
* 使用 SHA-1 算法计算 HMAC。
* @param key - 密钥，可以是字符串或 BufferSource。
* @param data - 需要计算 HMAC 的数据，可以是字符串或 BufferSource。
* @returns 返回十六进制格式的 HMAC 字符串。
* @since 1.8.0
* @example
* ```ts
* const hmac = (await sha1HMAC('secret-key', 'Hello, World!')).unwrap();
* console.log(hmac); // 十六进制 HMAC 字符串
* ```
*/
function sha1HMAC(key, data) {
return shaHMAC("SHA-1", key, data);
}
/**
* 使用 SHA-256 算法计算 HMAC。
* @param key - 密钥，可以是字符串或 BufferSource。
* @param data - 需要计算 HMAC 的数据，可以是字符串或 BufferSource。
* @returns 返回十六进制格式的 HMAC 字符串。
* @since 1.8.0
* @example
* ```ts
* const hmac = (await sha256HMAC('secret-key', 'Hello, World!')).unwrap();
* console.log(hmac); // 十六进制 HMAC 字符串
* ```
*/
function sha256HMAC(key, data) {
return shaHMAC("SHA-256", key, data);
}
/**
* 使用 SHA-384 算法计算 HMAC。
* @param key - 密钥，可以是字符串或 BufferSource。
* @param data - 需要计算 HMAC 的数据，可以是字符串或 BufferSource。
* @returns 返回十六进制格式的 HMAC 字符串。
* @since 1.8.0
* @example
* ```ts
* const hmac = (await sha384HMAC('secret-key', 'Hello, World!')).unwrap();
* console.log(hmac); // 十六进制 HMAC 字符串
* ```
*/
function sha384HMAC(key, data) {
return shaHMAC("SHA-384", key, data);
}
/**
* 使用 SHA-512 算法计算 HMAC。
* @param key - 密钥，可以是字符串或 BufferSource。
* @param data - 需要计算 HMAC 的数据，可以是字符串或 BufferSource。
* @returns 返回十六进制格式的 HMAC 字符串。
* @since 1.8.0
* @example
* ```ts
* const hmac = (await sha512HMAC('secret-key', 'Hello, World!')).unwrap();
* console.log(hmac); // 十六进制 HMAC 字符串
* ```
*/
function sha512HMAC(key, data) {
return shaHMAC("SHA-512", key, data);
}
/**
* 使用指定 SHA 算法计算 HMAC。
*/
function shaHMAC(sha, key, data) {
return (IS_MINA ? createHMAC$1 : createHMAC)(sha, key, data);
}
//#endregion
//#region src/std/crypto/md/md5.ts
/**
* Forked from https://github.com/denoland/std/blob/0.160.0/hash/md5.ts
*/
const BLOCK_SIZE = 64;
/**
* MD5 哈希计算类，支持流式更新。
* @since 1.0.0
* @example
* ```ts
* // 基本用法
* const hash = new Md5().update('Hello, World!').toString();
* console.log(hash); // '65a8e27d8879283831b664bd8b7f0ad4'
*
* // 流式更新
* const md5 = new Md5();
* md5.update('Hello, ');
* md5.update('World!');
* console.log(md5.toString()); // '65a8e27d8879283831b664bd8b7f0ad4'
*
* // 获取 ArrayBuffer
* const buffer = new Md5().update('test').digest();
* ```
*/
var Md5 = class {
a = 1732584193;
b = 4023233417;
c = 2562383102;
d = 271733878;
block = new Uint8Array(BLOCK_SIZE);
pos = 0;
n0 = 0;
n1 = 0;
/**
* 累加已处理的消息长度。
*
* n0 和 n1 共同组成一个 64 位计数器，用于记录消息的总字节数。
* - n0: 低 32 位
* - n1: 高 32 位
*
* 当 n0 溢出（超过 0xffffffff，即 2^32 - 1）时，需要向 n1 进位。
*
* @param len - 本次处理的字节数
*/
addLength(len) {
let n0 = this.n0;
n0 += len;
/* v8 ignore start */
if (n0 > 4294967295) this.n1 += 1;
/* v8 ignore stop */
this.n0 = n0 >>> 0;
}
hash(block) {
let a = this.a;
let b = this.b;
let c = this.c;
let d = this.d;
const blk = (i) => block[i] | block[i + 1] << 8 | block[i + 2] << 16 | block[i + 3] << 24;
const rol32 = (x, n) => x << n | x >>> 32 - n;
const x0 = blk(0);
const x1 = blk(4);
const x2 = blk(8);
const x3 = blk(12);
const x4 = blk(16);
const x5 = blk(20);
const x6 = blk(24);
const x7 = blk(28);
const x8 = blk(32);
const x9 = blk(36);
const xa = blk(40);
const xb = blk(44);
const xc = blk(48);
const xd = blk(52);
const xe = blk(56);
const xf = blk(60);
a = b + rol32(((c ^ d) & b ^ d) + a + x0 + 3614090360, 7);
d = a + rol32(((b ^ c) & a ^ c) + d + x1 + 3905402710, 12);
c = d + rol32(((a ^ b) & d ^ b) + c + x2 + 606105819, 17);
b = c + rol32(((d ^ a) & c ^ a) + b + x3 + 3250441966, 22);
a = b + rol32(((c ^ d) & b ^ d) + a + x4 + 4118548399, 7);
d = a + rol32(((b ^ c) & a ^ c) + d + x5 + 1200080426, 12);
c = d + rol32(((a ^ b) & d ^ b) + c + x6 + 2821735955, 17);
b = c + rol32(((d ^ a) & c ^ a) + b + x7 + 4249261313, 22);
a = b + rol32(((c ^ d) & b ^ d) + a + x8 + 1770035416, 7);
d = a + rol32(((b ^ c) & a ^ c) + d + x9 + 2336552879, 12);
c = d + rol32(((a ^ b) & d ^ b) + c + xa + 4294925233, 17);
b = c + rol32(((d ^ a) & c ^ a) + b + xb + 2304563134, 22);
a = b + rol32(((c ^ d) & b ^ d) + a + xc + 1804603682, 7);
d = a + rol32(((b ^ c) & a ^ c) + d + xd + 4254626195, 12);
c = d + rol32(((a ^ b) & d ^ b) + c + xe + 2792965006, 17);
b = c + rol32(((d ^ a) & c ^ a) + b + xf + 1236535329, 22);
a = b + rol32(((b ^ c) & d ^ c) + a + x1 + 4129170786, 5);
d = a + rol32(((a ^ b) & c ^ b) + d + x6 + 3225465664, 9);
c = d + rol32(((d ^ a) & b ^ a) + c + xb + 643717713, 14);
b = c + rol32(((c ^ d) & a ^ d) + b + x0 + 3921069994, 20);
a = b + rol32(((b ^ c) & d ^ c) + a + x5 + 3593408605, 5);
d = a + rol32(((a ^ b) & c ^ b) + d + xa + 38016083, 9);
c = d + rol32(((d ^ a) & b ^ a) + c + xf + 3634488961, 14);
b = c + rol32(((c ^ d) & a ^ d) + b + x4 + 3889429448, 20);
a = b + rol32(((b ^ c) & d ^ c) + a + x9 + 568446438, 5);
d = a + rol32(((a ^ b) & c ^ b) + d + xe + 3275163606, 9);
c = d + rol32(((d ^ a) & b ^ a) + c + x3 + 4107603335, 14);
b = c + rol32(((c ^ d) & a ^ d) + b + x8 + 1163531501, 20);
a = b + rol32(((b ^ c) & d ^ c) + a + xd + 2850285829, 5);
d = a + rol32(((a ^ b) & c ^ b) + d + x2 + 4243563512, 9);
c = d + rol32(((d ^ a) & b ^ a) + c + x7 + 1735328473, 14);
b = c + rol32(((c ^ d) & a ^ d) + b + xc + 2368359562, 20);
a = b + rol32((b ^ c ^ d) + a + x5 + 4294588738, 4);
d = a + rol32((a ^ b ^ c) + d + x8 + 2272392833, 11);
c = d + rol32((d ^ a ^ b) + c + xb + 1839030562, 16);
b = c + rol32((c ^ d ^ a) + b + xe + 4259657740, 23);
a = b + rol32((b ^ c ^ d) + a + x1 + 2763975236, 4);
d = a + rol32((a ^ b ^ c) + d + x4 + 1272893353, 11);
c = d + rol32((d ^ a ^ b) + c + x7 + 4139469664, 16);
b = c + rol32((c ^ d ^ a) + b + xa + 3200236656, 23);
a = b + rol32((b ^ c ^ d) + a + xd + 681279174, 4);
d = a + rol32((a ^ b ^ c) + d + x0 + 3936430074, 11);
c = d + rol32((d ^ a ^ b) + c + x3 + 3572445317, 16);
b = c + rol32((c ^ d ^ a) + b + x6 + 76029189, 23);
a = b + rol32((b ^ c ^ d) + a + x9 + 3654602809, 4);
d = a + rol32((a ^ b ^ c) + d + xc + 3873151461, 11);
c = d + rol32((d ^ a ^ b) + c + xf + 530742520, 16);
b = c + rol32((c ^ d ^ a) + b + x2 + 3299628645, 23);
a = b + rol32((c ^ (b | ~d)) + a + x0 + 4096336452, 6);
d = a + rol32((b ^ (a | ~c)) + d + x7 + 1126891415, 10);
c = d + rol32((a ^ (d | ~b)) + c + xe + 2878612391, 15);
b = c + rol32((d ^ (c | ~a)) + b + x5 + 4237533241, 21);
a = b + rol32((c ^ (b | ~d)) + a + xc + 1700485571, 6);
d = a + rol32((b ^ (a | ~c)) + d + x3 + 2399980690, 10);
c = d + rol32((a ^ (d | ~b)) + c + xa + 4293915773, 15);
b = c + rol32((d ^ (c | ~a)) + b + x1 + 2240044497, 21);
a = b + rol32((c ^ (b | ~d)) + a + x8 + 1873313359, 6);
d = a + rol32((b ^ (a | ~c)) + d + xf + 4264355552, 10);
c = d + rol32((a ^ (d | ~b)) + c + x6 + 2734768916, 15);
b = c + rol32((d ^ (c | ~a)) + b + xd + 1309151649, 21);
a = b + rol32((c ^ (b | ~d)) + a + x4 + 4149444226, 6);
d = a + rol32((b ^ (a | ~c)) + d + xb + 3174756917, 10);
c = d + rol32((a ^ (d | ~b)) + c + x2 + 718787259, 15);
b = c + rol32((d ^ (c | ~a)) + b + x9 + 3951481745, 21);
this.a = this.a + a >>> 0;
this.b = this.b + b >>> 0;
this.c = this.c + c >>> 0;
this.d = this.d + d >>> 0;
}
/**
* 更新内部状态。
* @param data - 要更新的数据，数据大小不能超过 2^32 字节。
*/
update(data) {
const msg = dataSourceToBytes(data);
let pos = this.pos;
const free = BLOCK_SIZE - pos;
if (msg.length < free) {
this.block.set(msg, pos);
pos += msg.length;
} else {
this.block.set(msg.slice(0, free), pos);
this.hash(this.block);
let i = free;
while (i + BLOCK_SIZE <= msg.length) {
this.hash(msg.slice(i, i + BLOCK_SIZE));
i += BLOCK_SIZE;
}
this.block.fill(0).set(msg.slice(i), 0);
pos = msg.length - i;
}
this.pos = pos;
this.addLength(msg.length);
return this;
}
/**
* 返回最终的哈希值。
*/
digest() {
let padLen = BLOCK_SIZE - this.pos;
if (padLen < 9) padLen += BLOCK_SIZE;
const pad = new Uint8Array(padLen);
pad[0] = 128;
const n0 = this.n0 << 3;
const n1 = this.n1 << 3 | this.n0 >>> 29;
pad[pad.length - 8] = n0 & 255;
pad[pad.length - 7] = n0 >>> 8 & 255;
pad[pad.length - 6] = n0 >>> 16 & 255;
pad[pad.length - 5] = n0 >>> 24 & 255;
pad[pad.length - 4] = n1 & 255;
pad[pad.length - 3] = n1 >>> 8 & 255;
pad[pad.length - 2] = n1 >>> 16 & 255;
pad[pad.length - 1] = n1 >>> 24 & 255;
this.update(pad.buffer);
const hash = /* @__PURE__ */ new ArrayBuffer(16);
const hashView = new DataView(hash);
hashView.setUint32(0, this.a, true);
hashView.setUint32(4, this.b, true);
hashView.setUint32(8, this.c, true);
hashView.setUint32(12, this.d, true);
return hash;
}
/**
* 以十六进制字符串形式返回哈希值。
*/
toString() {
return encodeHex(this.digest());
}
};
//#endregion
//#region src/std/crypto/md/mod.ts
/**
* 计算字符串或 Buffer 的 MD5 值。
* @param data - 需要计算 MD5 值的数据，可以是字符串或 BufferSource。
* @returns 计算得到的 MD5 十六进制字符串（32 位）。
* @since 1.0.0
* @example
* ```ts
* const hash = md5('Hello, World!');
* console.log(hash); // '65a8e27d8879283831b664bd8b7f0ad4'
* ```
*/
function md5(data) {
return new Md5().update(data).toString();
}
//#endregion
//#region src/std/crypto/random/mina_random.ts
/**
* @internal
* 小游戏平台的随机数生成实现。
*/
/**
* 缓存加密模块。
*/
const cryptoManager = /*#__PURE__*/ Lazy(() => wx.getUserCryptoManager());
/**
* 生成指定长度的加密随机字节数组。
* @param length - 要生成的随机字节数。
* @returns 返回包含随机字节的 Uint8Array。
*/
async function getRandomValues$2(length) {
return (await asyncIOResultify(cryptoManager.force().getRandomValues)({ length })).map((x) => new Uint8Array(x.randomValues));
}
/**
* 生成符合 RFC 4122 规范的 UUID v4。
* @returns 返回生成的 UUID 字符串。
*/
async function randomUUID$2() {
return (await getRandomValues$2(16)).map((bytes) => {
bytes[6] = bytes[6] & 15 | 64;
bytes[8] = bytes[8] & 63 | 128;
const hex = encodeHex(bytes);
return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
});
}
//#endregion
//#region src/std/crypto/random/web_random.ts
/**
* @internal
* Web 平台的随机数生成实现。
*/
/**
* 生成指定长度的加密随机字节数组。
* @param length - 要生成的随机字节数。
* @returns 返回包含随机字节的 Uint8Array。
*/
function getRandomValues$1(length) {
const bytes = new Uint8Array(length);
return tryResult(() => crypto.getRandomValues(bytes));
}
/**
* 生成符合 RFC 4122 规范的 UUID v4。
* @returns 返回生成的 UUID 字符串。
*/
function randomUUID$1() {
return crypto.randomUUID();
}
//#endregion
//#region src/std/crypto/random/mod.ts
/**
* 获取密码学安全的随机数。
* @param length - 要生成的随机字节数。
* @returns 包含随机数据的 Uint8Array，封装在 IOResult 中。
* @since 1.7.0
* @example
* ```ts
* const result = await getRandomValues(16);
* if (result.isOk()) {
* console.log(result.unwrap()); // Uint8Array(16) [...]
* }
* ```
*/
function getRandomValues(length) {
const validateResult = validatePositiveInteger(length, "length");
if (validateResult.isErr()) return Promise.resolve(validateResult.asErr());
return IS_MINA ? getRandomValues$2(length) : Promise.resolve(getRandomValues$1(length));
}
/**
* 生成符合 RFC 4122 标准的 UUID v4。
* @returns UUID 字符串，封装在 IOResult 中。
* @since 1.7.0
* @example
* ```ts
* const result = await randomUUID();
* if (result.isOk()) {
* console.log(result.unwrap()); // 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'
* }
* ```
*/
function randomUUID() {
return IS_MINA ? randomUUID$2() : Promise.resolve(Ok(randomUUID$1()));
}
//#endregion
//#region src/std/crypto/rsa/mina_rsa.ts
/**
* @internal
* 小游戏平台的 RSA 加密实现。
*/
/**
* 从 PEM 编码的字符串导入用于加密的公钥。
* @param pem - PEM 编码的字符串。
* @param hash - 哈希算法。
* @returns RSA 公钥对象。
*/
function importPublicKey$3(pem, hash) {
const publicKeyRes = tryResult(() => importPublicKey(pem));
if (publicKeyRes.isErr()) return Promise.resolve(publicKeyRes.asErr());
const shaFactory = getShaFactory(hash);
const publicKey = publicKeyRes.unwrap();
const encrypt = (data) => {
return tryResult(() => {
const decodedData = typeof data === "string" ? data : decodeUtf8(data);
return publicKey.encrypt(decodedData, shaFactory.create());
});
};
return Promise.resolve(Ok({
encrypt(data) {
return Promise.resolve(encrypt(data));
},
encryptToString(data) {
return Promise.resolve(encrypt(data).map(encodeBase64));
}
}));
}
/**
* 根据算法名称获取 SHA 哈希工厂。
*/
function getShaFactory(hash) {
switch (hash) {
case "SHA-1": return sha1$1;
case "SHA-256": return sha256$1;
case "SHA-384": return sha384$1;
case "SHA-512": return sha512$1;
}
}
//#endregion
//#region src/std/crypto/rsa/web_rsa.ts
/**
* @internal
* Web 平台的 RSA 加密实现。
*/
/**
* 从 PEM 编码的字符串导入用于加密的公钥。
* @param pem - PEM 编码的字符串。
* @param hash - 哈希算法。
* @returns RSA 公钥对象。
*/
function importPublicKey$2(pem, hash) {
const match = /\s*-----BEGIN ([A-Z0-9- ]+)-----\r?\n?([\x21-\x7e\s]+?(?:\r?\n\r?\n))?([:A-Za-z0-9+/=\s]+?)-----END \1-----/g.exec(pem);
if (!match) return Promise.resolve(Err(/* @__PURE__ */ new TypeError("Invalid PEM formatted message")));
pem = match[3];
return tryAsyncResult(async () => {
const keyData = decodeByteString(atob(pem));
const publicKey = await crypto.subtle.importKey("spki", keyData, {
name: "RSA-OAEP",
hash
}, false, ["encrypt"]);
return {
encrypt(data) {
return encrypt(publicKey, data);
},
async encryptToString(data) {
return (await encrypt(publicKey, data)).map(encodeBase64);
}
};
});
}
/**
* 使用公钥加密数据。
*/
function encrypt(publicKey, data) {
return tryAsyncResult(() => {
return crypto.subtle.encrypt({ name: "RSA-OAEP" }, publicKey, dataSourceToBytes(data));
});
}
//#endregion
//#region src/std/crypto/rsa/mod.ts
var rsa_exports = /* @__PURE__ */ __exportAll({ importPublicKey: () => importPublicKey$1 });
/**
* 从 PEM 格式的字符串导入 RSA 公钥，用于加密操作。
* @param pem - PEM 格式的公钥字符串。
* @param hash - 用于 OAEP 填充的哈希算法（SHA-1、SHA-256、SHA-384 或 SHA-512）。
* @returns RSA 公钥对象，包含 encrypt 方法用于加密数据。
* @since 1.6.0
* @example
* ```ts
* const publicKey = (await importPublicKey(pemString, 'SHA-256')).unwrap();
*
* // 加密并返回 ArrayBuffer
* const encrypted = (await publicKey.encrypt('Hello, World!')).unwrap();
*
* // 加密并返回 Base64 字符串
* const encryptedStr = (await publicKey.encryptToString('Hello, World!')).unwrap();
* ```
*/
function importPublicKey$1(pem, hash) {
if (hash !== "SHA-1" && hash !== "SHA-256" && hash !== "SHA-384" && hash !== "SHA-512") return Promise.resolve(Err(/* @__PURE__ */ new TypeError(`Unsupported hash algorithm: ${hash}`)));
return (IS_MINA ? importPublicKey$3 : importPublicKey$2)(pem, hash);
}
//#endregion
//#region src/std/crypto/sha/sha.ts
/**
* @internal
* 小游戏平台的 SHA 哈希实现。
*/
/**
* 计算 SHA-1 哈希值。
* @param data - 要计算哈希的数据。
* @returns 返回十六进制格式的哈希字符串。
*/
function sha1$2(data) {
return sha1$1.create().update(encodeByteString(data)).digest().toHex();
}
/**
* 计算 SHA-256 哈希值。
* @param data - 要计算哈希的数据。
* @returns 返回十六进制格式的哈希字符串。
*/
function sha256$2(data) {
return sha256$1.create().update(encodeByteString(data)).digest().toHex();
}
/**
* 计算 SHA-384 哈希值。
* @param data - 要计算哈希的数据。
* @returns 返回十六进制格式的哈希字符串。
*/
function sha384$2(data) {
return sha384$1.create().update(encodeByteString(data)).digest().toHex();
}
/**
* 计算 SHA-512 哈希值。
* @param data - 要计算哈希的数据。
* @returns 返回十六进制格式的哈希字符串。
*/
function sha512$2(data) {
return sha512$1.create().update(encodeByteString(data)).digest().toHex();
}
//#endregion
//#region src/std/crypto/sha/web_sha.ts
/**
* @internal
* Web 平台的 SHA 哈希实现。
*/
/**
* 根据不同 SHA 算法计算字符串或者 buffer 的哈希值，结果用16进制字符串表示。
* @param data - 需要计算哈希值的数据。
* @param hash - SHA 算法。
* @returns 计算得到的哈希值。
*/
function sha(data, hash) {
return tryAsyncResult(async () => {
return encodeHex(await crypto.subtle.digest(hash, dataSourceToBytes(data)));
});
}
//#endregion
//#region src/std/crypto/sha/mod.ts
/**
* 计算数据的 SHA-1 哈希值。
* @param data - 需要计算哈希的数据，可以是字符串或 BufferSource。
* @returns 返回十六进制格式的哈希字符串。
* @since 1.6.0
* @example
* ```ts
* const hash = await sha1('Hello, World!');
* if (hash.isOk()) {
* console.log(hash.unwrap()); // 十六进制哈希字符串
* }
* ```
*/
function sha1(data) {
return IS_MINA ? Promise.resolve(Ok(sha1$2(data))) : sha(data, "SHA-1");
}
/**
* 计算数据的 SHA-256 哈希值。
* @param data - 需要计算哈希的数据，可以是字符串或 BufferSource。
* @returns 返回十六进制格式的哈希字符串。
* @since 1.0.0
* @example
* ```ts
* const hash = await sha256('Hello, World!');
* if (hash.isOk()) {
* console.log(hash.unwrap()); // 十六进制哈希字符串
* }
* ```
*/
function sha256(data) {
return IS_MINA ? Promise.resolve(Ok(sha256$2(data))) : sha(data, "SHA-256");
}
/**
* 计算数据的 SHA-384 哈希值。
* @param data - 需要计算哈希的数据，可以是字符串或 BufferSource。
* @returns 返回十六进制格式的哈希字符串。
* @since 1.6.0
* @example
* ```ts
* const hash = await sha384('Hello, World!');
* if (hash.isOk()) {
* console.log(hash.unwrap()); // 十六进制哈希字符串
* }
* ```
*/
function sha384(data) {
return IS_MINA ? Promise.resolve(Ok(sha384$2(data))) : sha(data, "SHA-384");
}
/**
* 计算数据的 SHA-512 哈希值。
* @param data - 需要计算哈希的数据，可以是字符串或 BufferSource。
* @returns 返回十六进制格式的哈希字符串。
* @since 1.6.0
* @example
* ```ts
* const hash = await sha512('Hello, World!');
* if (hash.isOk()) {
* console.log(hash.unwrap()); // 十六进制哈希字符串
* }
* ```
*/
function sha512(data) {
return IS_MINA ? Promise.resolve(Ok(sha512$2(data))) : sha(data, "SHA-512");
}
//#endregion
export { Md5, getRandomValues, md5, randomUUID, rsa_exports as rsa, sha1, sha1HMAC, sha256, sha256HMAC, sha384, sha384HMAC, sha512, sha512HMAC };
//# sourceMappingURL=cryptos.mjs.map