@h-ai/crypto 1.0.0-beta.2 → 1.0.0-beta.20

package/dist/index.js

@@ -58,7 +58,9 @@ var en_US_default = {
   crypto_transportSessionKeyDecryptFailed: "Failed to decrypt transport session key",
   crypto_transportBodyLimitInvalid: "Transport plaintext limit must be an integer between 1024 and 67108864 bytes",
   crypto_transportBodyTooLarge: "Encrypted transport payload exceeds the configured byte limit",
-  crypto_transportTimeInvalid: "Your device and server clocks may be out of sync, or the request has expired. Enable automatic time synchronization and refresh to retry. If this continues, ask an administrator to check the server clock.",
+  crypto_transportTimeInvalid: "Your device and server clocks may be out of sync, or the request has expired. Enable automatic time synchronization or set your device time manually, then refresh to retry. If this continues, ask an administrator to check the server clock.",
+  crypto_transportTimeInvalidWithServerTime: "Your device and server clocks may be out of sync, or the request has expired. Server time is {serverTime}. Enable automatic time synchronization or set your device time manually, then refresh to retry. If this continues, ask an administrator to check the server clock.",
+  crypto_transportTimeConfigInvalid: "Invalid transport time settings. Future clock skew must be an integer from 0 to 300 seconds and request lifetime from 1 to 600 seconds.",
   crypto_transportBodyLimitConflict: "Explicit transport limit {limit} bytes is below the enabled module requirement of {required} bytes; adjust the module budget or explicit limit",
   crypto_transportBusy: "Material processing is busy. Please retry shortly."
 };
@@ -118,7 +120,9 @@ var ja_JP_default = {
   crypto_transportSessionKeyDecryptFailed: "\u901A\u4FE1\u30BB\u30C3\u30B7\u30E7\u30F3\u9375\u306E\u5FA9\u53F7\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
   crypto_transportBodyLimitInvalid: "\u901A\u4FE1\u5E73\u6587\u306E\u4E0A\u9650\u306F 1024 \u304B\u3089 67108864 \u30D0\u30A4\u30C8\u306E\u6574\u6570\u3067\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044",
   crypto_transportBodyTooLarge: "\u6697\u53F7\u5316\u901A\u4FE1\u306E\u30C7\u30FC\u30BF\u304C\u8A2D\u5B9A\u3055\u308C\u305F\u30D0\u30A4\u30C8\u4E0A\u9650\u3092\u8D85\u3048\u3066\u3044\u307E\u3059",
-  crypto_transportTimeInvalid: "\u7AEF\u672B\u3068\u30B5\u30FC\u30D0\u30FC\u306E\u6642\u523B\u304C\u540C\u671F\u3057\u3066\u3044\u306A\u3044\u304B\u3001\u8981\u6C42\u306E\u6709\u52B9\u671F\u9650\u304C\u5207\u308C\u3066\u3044\u307E\u3059\u3002\u81EA\u52D5\u6642\u523B\u540C\u671F\u3092\u6709\u52B9\u306B\u3057\u3066\u30DA\u30FC\u30B8\u3092\u518D\u8AAD\u307F\u8FBC\u307F\u3057\u3066\u304F\u3060\u3055\u3044\u3002\u89E3\u6D88\u3057\u306A\u3044\u5834\u5408\u306F\u7BA1\u7406\u8005\u306B\u30B5\u30FC\u30D0\u30FC\u306E\u6642\u523B\u78BA\u8A8D\u3092\u4F9D\u983C\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
+  crypto_transportTimeInvalid: "\u7AEF\u672B\u3068\u30B5\u30FC\u30D0\u30FC\u306E\u6642\u523B\u304C\u540C\u671F\u3057\u3066\u3044\u306A\u3044\u304B\u3001\u8981\u6C42\u306E\u6709\u52B9\u671F\u9650\u304C\u5207\u308C\u3066\u3044\u307E\u3059\u3002\u7AEF\u672B\u306E\u81EA\u52D5\u6642\u523B\u540C\u671F\u3092\u6709\u52B9\u306B\u3059\u308B\u304B\u3001\u624B\u52D5\u3067\u6642\u523B\u3092\u8A2D\u5B9A\u3057\u3066\u304B\u3089\u3001\u30DA\u30FC\u30B8\u3092\u518D\u8AAD\u307F\u8FBC\u307F\u3057\u3066\u304F\u3060\u3055\u3044\u3002\u89E3\u6D88\u3057\u306A\u3044\u5834\u5408\u306F\u7BA1\u7406\u8005\u306B\u30B5\u30FC\u30D0\u30FC\u306E\u6642\u523B\u78BA\u8A8D\u3092\u4F9D\u983C\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
+  crypto_transportTimeInvalidWithServerTime: "\u7AEF\u672B\u3068\u30B5\u30FC\u30D0\u30FC\u306E\u6642\u523B\u304C\u540C\u671F\u3057\u3066\u3044\u306A\u3044\u304B\u3001\u8981\u6C42\u306E\u6709\u52B9\u671F\u9650\u304C\u5207\u308C\u3066\u3044\u307E\u3059\u3002\u30B5\u30FC\u30D0\u30FC\u6642\u523B\u306F {serverTime} \u3067\u3059\u3002\u7AEF\u672B\u306E\u81EA\u52D5\u6642\u523B\u540C\u671F\u3092\u6709\u52B9\u306B\u3059\u308B\u304B\u3001\u624B\u52D5\u3067\u6642\u523B\u3092\u8A2D\u5B9A\u3057\u3066\u304B\u3089\u3001\u30DA\u30FC\u30B8\u3092\u518D\u8AAD\u307F\u8FBC\u307F\u3057\u3066\u304F\u3060\u3055\u3044\u3002\u89E3\u6D88\u3057\u306A\u3044\u5834\u5408\u306F\u7BA1\u7406\u8005\u306B\u30B5\u30FC\u30D0\u30FC\u306E\u6642\u523B\u78BA\u8A8D\u3092\u4F9D\u983C\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
+  crypto_transportTimeConfigInvalid: "\u30C8\u30E9\u30F3\u30B9\u30DD\u30FC\u30C8\u306E\u6642\u523B\u8A2D\u5B9A\u304C\u7121\u52B9\u3067\u3059\u3002\u672A\u6765\u65B9\u5411\u306E\u6642\u523B\u5DEE\u306F 0\uFF5E300 \u79D2\u3001\u8981\u6C42\u306E\u6709\u52B9\u671F\u9593\u306F 1\uFF5E600 \u79D2\u306E\u6574\u6570\u3067\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
   crypto_transportBodyLimitConflict: "\u660E\u793A\u3055\u308C\u305F\u8EE2\u9001\u4E0A\u9650 {limit} \u30D0\u30A4\u30C8\u306F\u6709\u52B9\u306A\u30E2\u30B8\u30E5\u30FC\u30EB\u306E\u5FC5\u8981\u91CF {required} \u30D0\u30A4\u30C8\u672A\u6E80\u3067\u3059\u3002\u4E88\u7B97\u307E\u305F\u306F\u4E0A\u9650\u3092\u5909\u66F4\u3057\u3066\u304F\u3060\u3055\u3044",
   crypto_transportBusy: "\u8CC7\u6599\u306E\u51E6\u7406\u304C\u6DF7\u307F\u5408\u3063\u3066\u3044\u307E\u3059\u3002\u3057\u3070\u3089\u304F\u3057\u3066\u304B\u3089\u518D\u8A66\u884C\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
 };
@@ -178,7 +182,9 @@ var zh_CN_default = {
   crypto_transportSessionKeyDecryptFailed: "\u4F20\u8F93\u52A0\u5BC6\u4F1A\u8BDD\u5BC6\u94A5\u89E3\u5BC6\u5931\u8D25",
   crypto_transportBodyLimitInvalid: "\u4F20\u8F93\u660E\u6587\u5BB9\u91CF\u5FC5\u987B\u662F 1024 \u5230 67108864 \u5B57\u8282\u4E4B\u95F4\u7684\u6574\u6570",
   crypto_transportBodyTooLarge: "\u52A0\u5BC6\u4F20\u8F93\u62A5\u6587\u8D85\u8FC7\u914D\u7F6E\u7684\u5B57\u8282\u4E0A\u9650",
-  crypto_transportTimeInvalid: "\u8BBE\u5907\u4E0E\u670D\u52A1\u5668\u65F6\u95F4\u53EF\u80FD\u4E0D\u540C\u6B65\uFF0C\u6216\u8BF7\u6C42\u5DF2\u8FC7\u671F\u3002\u8BF7\u5F00\u542F\u81EA\u52A8\u6821\u65F6\u5E76\u5237\u65B0\u91CD\u8BD5\uFF1B\u82E5\u4ECD\u5931\u8D25\uFF0C\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458\u68C0\u67E5\u670D\u52A1\u5668\u65F6\u95F4\u3002",
+  crypto_transportTimeInvalid: "\u8BBE\u5907\u4E0E\u670D\u52A1\u5668\u65F6\u95F4\u53EF\u80FD\u4E0D\u540C\u6B65\uFF0C\u6216\u8BF7\u6C42\u5DF2\u8FC7\u671F\u3002\u8BF7\u5F00\u542F\u8BBE\u5907\u7684\u81EA\u52A8\u6821\u65F6\u6216\u624B\u5DE5\u4FEE\u6539\u65F6\u95F4\uFF0C\u7136\u540E\u5237\u65B0\u91CD\u8BD5\u3002\u82E5\u4ECD\u5931\u8D25\uFF0C\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458\u68C0\u67E5\u670D\u52A1\u5668\u65F6\u95F4\u3002",
+  crypto_transportTimeInvalidWithServerTime: "\u8BBE\u5907\u4E0E\u670D\u52A1\u5668\u65F6\u95F4\u53EF\u80FD\u4E0D\u540C\u6B65\uFF0C\u6216\u8BF7\u6C42\u5DF2\u8FC7\u671F\u3002\u670D\u52A1\u5668\u65F6\u95F4\u4E3A {serverTime}\u3002\u8BF7\u5F00\u542F\u8BBE\u5907\u7684\u81EA\u52A8\u6821\u65F6\u6216\u624B\u5DE5\u4FEE\u6539\u65F6\u95F4\uFF0C\u7136\u540E\u5237\u65B0\u91CD\u8BD5\u3002\u82E5\u4ECD\u5931\u8D25\uFF0C\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458\u68C0\u67E5\u670D\u52A1\u5668\u65F6\u95F4\u3002",
+  crypto_transportTimeConfigInvalid: "\u4F20\u8F93\u65F6\u95F4\u914D\u7F6E\u65E0\u6548\u3002\u5141\u8BB8\u7684\u672A\u6765\u504F\u5DEE\u987B\u4E3A 0 \u81F3 300 \u79D2\u7684\u6574\u6570\uFF0C\u8BF7\u6C42\u6709\u6548\u671F\u987B\u4E3A 1 \u81F3 600 \u79D2\u7684\u6574\u6570\u3002",
   crypto_transportBodyLimitConflict: "\u663E\u5F0F\u4F20\u8F93\u4E0A\u9650 {limit} \u5B57\u8282\u5C0F\u4E8E\u5DF2\u542F\u7528\u6A21\u5757\u6240\u9700\u7684 {required} \u5B57\u8282\uFF1B\u8BF7\u8C03\u6574\u6A21\u5757\u9884\u7B97\u6216\u663E\u5F0F\u4E0A\u9650",
   crypto_transportBusy: "\u6750\u6599\u5904\u7406\u7E41\u5FD9\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5"
 };
@@ -379,7 +385,11 @@ function createSM2() {
       } catch (error) {
         return err(
           HaiCryptoError.KEY_GENERATION_FAILED,
-          cryptoM("crypto_sm2KeyPairGenerateFailed", { params: { error: error instanceof Error ? error.message : String(error) } }),
+          cryptoM("crypto_sm2KeyPairGenerateFailed", {
+            params: {
+              error: error instanceof Error ? error.message : String(error)
+            }
+          }),
           error
         );
       }
@@ -418,7 +428,11 @@ function createSM2() {
       } catch (error) {
         return err(
           HaiCryptoError.ENCRYPTION_FAILED,
-          cryptoM("crypto_sm2EncryptFailed", { params: { error: error instanceof Error ? error.message : String(error) } }),
+          cryptoM("crypto_sm2EncryptFailed", {
+            params: {
+              error: error instanceof Error ? error.message : String(error)
+            }
+          }),
           error
         );
       }
@@ -457,7 +471,11 @@ function createSM2() {
       } catch (error) {
         return err(
           HaiCryptoError.DECRYPTION_FAILED,
-          cryptoM("crypto_sm2DecryptFailedWithError", { params: { error: error instanceof Error ? error.message : String(error) } }),
+          cryptoM("crypto_sm2DecryptFailedWithError", {
+            params: {
+              error: error instanceof Error ? error.message : String(error)
+            }
+          }),
           error
         );
       }
@@ -492,7 +510,11 @@ function createSM2() {
       } catch (error) {
         return err(
           HaiCryptoError.SIGN_FAILED,
-          cryptoM("crypto_sm2SignFailed", { params: { error: error instanceof Error ? error.message : String(error) } }),
+          cryptoM("crypto_sm2SignFailed", {
+            params: {
+              error: error instanceof Error ? error.message : String(error)
+            }
+          }),
           error
         );
       }
@@ -523,7 +545,11 @@ function createSM2() {
       } catch (error) {
         return err(
           HaiCryptoError.VERIFY_FAILED,
-          cryptoM("crypto_sm2VerifyFailed", { params: { error: error instanceof Error ? error.message : String(error) } }),
+          cryptoM("crypto_sm2VerifyFailed", {
+            params: {
+              error: error instanceof Error ? error.message : String(error)
+            }
+          }),
           error
         );
       }
@@ -589,7 +615,11 @@ function createSM3() {
       } catch (error) {
         return err(
           HaiCryptoError.HASH_FAILED,
-          cryptoM("crypto_sm3HashFailed", { params: { error: error instanceof Error ? error.message : String(error) } }),
+          cryptoM("crypto_sm3HashFailed", {
+            params: {
+              error: error instanceof Error ? error.message : String(error)
+            }
+          }),
           error
         );
       }
@@ -628,7 +658,11 @@ function createSM3() {
       } catch (error) {
         return err(
           HaiCryptoError.HMAC_FAILED,
-          cryptoM("crypto_sm3HmacFailed", { params: { error: error instanceof Error ? error.message : String(error) } }),
+          cryptoM("crypto_sm3HmacFailed", {
+            params: {
+              error: error instanceof Error ? error.message : String(error)
+            }
+          }),
           error
         );
       }
@@ -649,7 +683,11 @@ function createSM3() {
       } catch (error) {
         return err(
           HaiCryptoError.HASH_FAILED,
-          cryptoM("crypto_sm3VerifyFailed", { params: { error: error instanceof Error ? error.message : String(error) } }),
+          cryptoM("crypto_sm3VerifyFailed", {
+            params: {
+              error: error instanceof Error ? error.message : String(error)
+            }
+          }),
           error
         );
       }
@@ -737,7 +775,11 @@ function createSM4() {
       } catch (error) {
         return err(
           HaiCryptoError.ENCRYPTION_FAILED,
-          cryptoM("crypto_sm4EncryptFailed", { params: { error: error instanceof Error ? error.message : String(error) } }),
+          cryptoM("crypto_sm4EncryptFailed", {
+            params: {
+              error: error instanceof Error ? error.message : String(error)
+            }
+          }),
           error
         );
       }
@@ -785,7 +827,11 @@ function createSM4() {
       } catch (error) {
         return err(
           HaiCryptoError.DECRYPTION_FAILED,
-          cryptoM("crypto_sm4DecryptFailedWithError", { params: { error: error instanceof Error ? error.message : String(error) } }),
+          cryptoM("crypto_sm4DecryptFailedWithError", {
+            params: {
+              error: error instanceof Error ? error.message : String(error)
+            }
+          }),
           error
         );
       }
@@ -821,7 +867,12 @@ function createSM4() {
      * @returns 成功时返回明文；失败时同 decrypt
      */
     decryptWithIV(ciphertext, key, iv) {
-      return this.decrypt({ mode: "cbc", ciphertext, iv, encoding: "hex" }, key);
+      return this.decrypt({
+        mode: "cbc",
+        ciphertext,
+        iv,
+        encoding: "hex"
+      }, key);
     },
     /** 校验密钥格式是否合法（32 字符十六进制） */
     isValidKey(key) {
@@ -867,8 +918,11 @@ function resolveTransportBodyLimits(maxPlaintextBytes, options = {}) {
     maxPlaintextBytes = required ?? TRANSPORT_BODY_LIMITS.plaintextBytes;
   if (!Number.isSafeInteger(maxPlaintextBytes) || maxPlaintextBytes < TRANSPORT_PLAINTEXT_RANGE.min || maxPlaintextBytes > TRANSPORT_PLAINTEXT_RANGE.max)
     throw new RangeError(cryptoM("crypto_transportBodyLimitInvalid"));
-  if (required !== void 0 && maxPlaintextBytes < required)
-    throw new RangeError(cryptoM("crypto_transportBodyLimitConflict", { params: { limit: maxPlaintextBytes, required } }));
+  if (required !== void 0 && maxPlaintextBytes < required) {
+    throw new RangeError(cryptoM("crypto_transportBodyLimitConflict", {
+      params: { limit: maxPlaintextBytes, required }
+    }));
+  }
   return Object.freeze({ ...TRANSPORT_BODY_LIMITS, plaintextBytes: maxPlaintextBytes, encryptedPayloadBytes: 2 * maxPlaintextBytes + 32768 });
 }
 var TransportBodyTooLargeError = class extends RangeError {
@@ -940,7 +994,10 @@ function createTransportBodyPolicy(maxPlaintextBytes, routes = {}) {
   const entries = Object.entries(routes);
   if (entries.length > 100 || entries.some(([path]) => !path.startsWith("/") || path.includes("?") || path.includes("#") || path.split("/").some((part) => part.includes("*") && part !== "*")))
     throw new RangeError(cryptoM("crypto_transportBodyLimitInvalid"));
-  const configured = entries.map(([path, bytes]) => ({ parts: path.split("/"), limits: resolveTransportBodyLimits(bytes) }));
+  const configured = entries.map(([path, bytes]) => ({
+    parts: path.split("/"),
+    limits: resolveTransportBodyLimits(bytes)
+  }));
   const maximum = resolveTransportBodyLimits(Math.max(ordinary.plaintextBytes, ...configured.map((route) => route.limits.plaintextBytes)));
   let small = 0;
   let large = 0;
@@ -951,22 +1008,26 @@ function createTransportBodyPolicy(maxPlaintextBytes, routes = {}) {
       const matching = configured.filter((route) => route.parts.length === parts.length && route.parts.every((part, index) => part === "*" || part === parts[index]));
       const limits = matching.length ? matching.reduce((left, right) => left.limits.plaintextBytes < right.limits.plaintextBytes ? left : right).limits : ordinary;
       const heavy = matching.length > 0 && limits.plaintextBytes > TRANSPORT_BODY_LIMITS.plaintextBytes;
-      if (heavy ? large >= 2 : small >= 16)
+      if (heavy ? large >= 2 : small >= 16) {
         return null;
+      }
       if (heavy)
         large++;
       else
         small++;
       let released = false;
-      return { limits, release() {
-        if (released)
-          return;
-        released = true;
-        if (heavy)
-          large--;
-        else
-          small--;
-      } };
+      return {
+        limits,
+        release() {
+          if (released)
+            return;
+          released = true;
+          if (heavy)
+            large--;
+          else
+            small--;
+        }
+      };
     }
   };
 }
@@ -979,9 +1040,9 @@ var TRANSPORT_PROTOCOL = {
   ENVELOPE_HEADER: "X-Hai-Transport",
   /** 唯一支持的认证协议版本；旧未认证格式拒绝。 */
   VERSION: 2,
-  /** 请求允许的过去时间窗口（毫秒）。 */
+  /** 默认请求有效期（毫秒）。 */
   REQUEST_WINDOW_MS: 3e5,
-  /** 节点时钟允许的最大未来偏差（毫秒）。 */
+  /** 默认允许的客户端未来偏差（毫秒），也是部署约定的节点对时误差上限。 */
   CLOCK_SKEW_MS: 3e4,
   /** 标识响应体已加密的响应头名。 */
   ENCRYPTED_HEADER: "X-Encrypted",
@@ -990,6 +1051,11 @@ var TRANSPORT_PROTOCOL = {
   /** 密钥协商端点的默认子路径（相对于挂载前缀）。 */
   DEFAULT_KEY_EXCHANGE_PATH: "/_hai/key-exchange"
 };
+var TRANSPORT_TIME_LIMITS = Object.freeze({
+  maxFutureSkewSeconds: 300,
+  minRequestAgeSeconds: 1,
+  maxRequestAgeSeconds: 600
+});
 
 // src/transport/crypto-transport-codec.ts
 function authenticatedText(payload) {
@@ -1034,7 +1100,14 @@ function sealTransportPayload(service, plaintext, context, direction, status, re
     const wrapped = service.asymmetric.encrypt(JSON.stringify([encryptionKey, authenticationKey]), recipientPublicKey);
     if (!encrypted.success || !wrapped.success)
       return transportAuthenticationFailure();
-    const payload = { context: { ...context }, direction, status, encryptedKey: wrapped.data, ciphertext: encrypted.data.ciphertext, iv: encrypted.data.iv };
+    const payload = {
+      context: { ...context },
+      direction,
+      status,
+      encryptedKey: wrapped.data,
+      ciphertext: encrypted.data.ciphertext,
+      iv: encrypted.data.iv
+    };
     const text = authenticatedText(payload);
     const tag = service.hash.hmac(text, authenticationKey);
     if (!tag.success)
@@ -1090,29 +1163,57 @@ function sameTransportContext(a, b) {
 
 // src/transport/crypto-transport-error.ts
 var TransportTimeError = class extends Error {
-  constructor(context) {
-    super(cryptoM("crypto_transportTimeInvalid"));
+  constructor(context, serverTime) {
+    const validTime = typeof serverTime === "number" && Number.isSafeInteger(serverTime) && serverTime >= 0 && serverTime <= 864e13 ? serverTime : void 0;
+    const message = validTime === void 0 ? cryptoM("crypto_transportTimeInvalid") : cryptoM("crypto_transportTimeInvalidWithServerTime", {
+      params: {
+        serverTime: new Date(validTime).toISOString().replace("T", " ").replace(/\.\d{3}Z$/, " UTC")
+      }
+    });
+    super(message);
     this.context = context;
     this.name = "TransportTimeError";
+    this.serverTime = validTime;
   }
   context;
   code = HaiCryptoError.TRANSPORT_TIME_INVALID.code;
+  serverTime;
 };
 async function createTransportErrorResponse(error, authenticated) {
-  const status = error instanceof TransportTimeError ? 400 : error.direction === "request" ? 413 : 500;
-  const body = JSON.stringify({ success: false, error: { code: error.code, message: error.message, httpStatus: status, details: error instanceof TransportTimeError ? void 0 : {
-    direction: error.direction,
-    stage: error.stage,
-    limitBytes: error.limitBytes,
-    actualBytes: error.actualBytes
-  } } });
+  const isTimeError = error instanceof TransportTimeError;
+  const status = isTimeError ? 400 : error.direction === "request" ? 413 : 500;
+  const publicError = {
+    code: error.code,
+    message: isTimeError ? cryptoM("crypto_transportTimeInvalid") : error.message,
+    httpStatus: status,
+    details: isTimeError ? void 0 : {
+      direction: error.direction,
+      stage: error.stage,
+      limitBytes: error.limitBytes,
+      actualBytes: error.actualBytes
+    }
+  };
   if (authenticated) {
+    const encryptedError = isTimeError && error.serverTime !== void 0 ? {
+      ...publicError,
+      message: error.message,
+      details: { serverTime: error.serverTime }
+    } : publicError;
+    const body = JSON.stringify({ success: false, error: encryptedError });
     const encrypted = await authenticated.manager.encryptResponse(authenticated.context, body, status);
     if (encrypted.success) {
-      return Response.json(encrypted.data, { status, headers: { [TRANSPORT_PROTOCOL.ENCRYPTED_HEADER]: TRANSPORT_PROTOCOL.ENCRYPTED_HEADER_VALUE } });
+      const headers = new Headers({ [TRANSPORT_PROTOCOL.ENCRYPTED_HEADER]: TRANSPORT_PROTOCOL.ENCRYPTED_HEADER_VALUE });
+      if (authenticated.context.method === "HEAD") {
+        headers.set(TRANSPORT_PROTOCOL.ENVELOPE_HEADER, JSON.stringify(encrypted.data));
+        return new Response(null, { status, headers });
+      }
+      return Response.json(encrypted.data, { status, headers });
     }
   }
-  return new Response(body, { status, headers: { "Content-Type": "application/json; charset=utf-8" } });
+  return new Response(JSON.stringify({ success: false, error: publicError }), {
+    status,
+    headers: { "Content-Type": "application/json; charset=utf-8" }
+  });
 }
 
 // src/transport/crypto-transport-client.ts
@@ -1125,7 +1226,9 @@ function createTransportClient(options) {
   let serverKeyId = null;
   let clientId = null;
   let initPromise = null;
-  async function doInit() {
+  let generation = 0;
+  let handshakeController;
+  async function doInit(attemptGeneration) {
     const kpResult = options.crypto.asymmetric.generateKeyPair();
     if (!kpResult.success)
       return err(HaiCommonError.INTERNAL_ERROR, cryptoM("crypto_transportClientKeyGenerateFailed"), kpResult.error);
@@ -1133,6 +1236,7 @@ function createTransportClient(options) {
     if (new TextEncoder().encode(localKeyPair.publicKey).byteLength > TRANSPORT_BODY_LIMITS.publicKeyBytes)
       return err(HaiCommonError.INTERNAL_ERROR, cryptoM("crypto_transportClientKeyGenerateFailed"));
     const controller = new AbortController();
+    handshakeController = controller;
     const timeout = setTimeout(() => controller.abort(new DOMException("Key exchange timed out", "TimeoutError")), 3e4);
     try {
       let response;
@@ -1149,7 +1253,9 @@ function createTransportClient(options) {
       if (!response.ok) {
         void response.body?.cancel().catch(() => {
         });
-        return err(HaiCommonError.INTERNAL_ERROR, cryptoM("crypto_transportKeyExchangeHttpFailed", { params: { status: response.status } }));
+        return err(HaiCommonError.INTERNAL_ERROR, cryptoM("crypto_transportKeyExchangeHttpFailed", {
+          params: { status: response.status }
+        }));
       }
       let body;
       try {
@@ -1169,6 +1275,8 @@ function createTransportClient(options) {
       } catch {
         return err(HaiCommonError.INTERNAL_ERROR, cryptoM("crypto_transportBodyLimitInvalid"));
       }
+      if (attemptGeneration !== generation || controller.signal.aborted)
+        return err(HaiCommonError.INTERNAL_ERROR, cryptoM("crypto_transportClientNotInitialized"));
       keyPair = localKeyPair;
       serverPublicKey = body.serverPublicKey;
       serverKeyId = body.serverKeyId;
@@ -1176,17 +1284,20 @@ function createTransportClient(options) {
       return ok(void 0);
     } finally {
       clearTimeout(timeout);
+      if (handshakeController === controller)
+        handshakeController = void 0;
     }
   }
   async function ensureReady() {
     if (clientId && serverPublicKey)
       return ok(void 0);
     if (!initPromise) {
-      initPromise = doInit().then((result) => {
-        if (!result.success)
+      const pending = doInit(generation).then((result) => {
+        if (!result.success && initPromise === pending)
           initPromise = null;
         return result;
       });
+      initPromise = pending;
     }
     return initPromise;
   }
@@ -1307,7 +1418,12 @@ function createTransportClient(options) {
       }
       if (envelope && new TextEncoder().encode(envelope).byteLength > TRANSPORT_BODY_LIMITS.envelopeHeaderBytes)
         throw new TransportBodyTooLargeError(TRANSPORT_BODY_LIMITS.envelopeHeaderBytes, new TextEncoder().encode(envelope).byteLength, { direction: "response", stage: "header" });
-      payload = JSON.parse(envelope ?? await readTransportBody(response.body, { maxBytes: bodyLimits.encryptedPayloadBytes, direction: "response", stage: "encrypted", signal }));
+      payload = JSON.parse(envelope ?? await readTransportBody(response.body, {
+        maxBytes: bodyLimits.encryptedPayloadBytes,
+        direction: "response",
+        stage: "encrypted",
+        signal
+      }));
     } catch (error) {
       if (error instanceof TransportBodyTooLargeError)
         throw error;
@@ -1330,8 +1446,10 @@ function createTransportClient(options) {
         failure = JSON.parse(decResult.data);
       } catch {
       }
-      if (failure?.success === false && failure.error?.code === HaiCryptoError.TRANSPORT_TIME_INVALID.code)
-        throw new TransportTimeError();
+      if (failure?.success === false && failure.error?.code === HaiCryptoError.TRANSPORT_TIME_INVALID.code) {
+        const serverTime = failure.error.details?.serverTime;
+        throw new TransportTimeError(void 0, typeof serverTime === "number" ? serverTime : void 0);
+      }
     }
     if (response.status === 500) {
       let failure;
@@ -1360,6 +1478,9 @@ function createTransportClient(options) {
     encryptedFetch,
     ready: () => clientId !== null && serverPublicKey !== null,
     destroy() {
+      generation++;
+      handshakeController?.abort();
+      handshakeController = void 0;
       keyPair = null;
       serverPublicKey = null;
       serverKeyId = null;
@@ -1409,6 +1530,16 @@ function isTransportServerKeyRing(value) {
 
 // src/transport/crypto-transport-server.ts
 function createTransportEncryption(cryptoService, options) {
+  const {
+    maxFutureSkewSeconds = TRANSPORT_PROTOCOL.CLOCK_SKEW_MS / 1e3,
+    maxRequestAgeSeconds = TRANSPORT_PROTOCOL.REQUEST_WINDOW_MS / 1e3
+  } = options ?? {};
+  if (!Number.isInteger(maxFutureSkewSeconds) || maxFutureSkewSeconds < 0 || maxFutureSkewSeconds > TRANSPORT_TIME_LIMITS.maxFutureSkewSeconds || !Number.isInteger(maxRequestAgeSeconds) || maxRequestAgeSeconds < TRANSPORT_TIME_LIMITS.minRequestAgeSeconds || maxRequestAgeSeconds > TRANSPORT_TIME_LIMITS.maxRequestAgeSeconds) {
+    return err(HaiCryptoError.INVALID_INPUT, cryptoM("crypto_transportTimeConfigInvalid"));
+  }
+  const futureSkewMs = maxFutureSkewSeconds * 1e3;
+  const requestAgeMs = maxRequestAgeSeconds * 1e3;
+  const nonceRetentionMs = TRANSPORT_TIME_LIMITS.maxRequestAgeSeconds * 1e3 + 2 * TRANSPORT_PROTOCOL.CLOCK_SKEW_MS;
   let bodyLimits;
   try {
     bodyLimits = resolveTransportBodyLimits(options?.maxPlaintextBytes);
@@ -1470,7 +1601,10 @@ function createTransportEncryption(cryptoService, options) {
       try {
         if (!isValidEncryptedPayload(payload, bodyLimits) || payload.direction !== "request" || payload.status !== 0)
           return transportAuthenticationFailure();
-        const authenticated = { ...payload, context: { ...payload.context } };
+        const authenticated = {
+          ...payload,
+          context: { ...payload.context }
+        };
         const c = authenticated.context;
         const pathHash = hashTransportPath(cryptoService, expected.path);
         if (!pathHash.success || c.clientId !== expected.clientId || c.method !== expected.method || c.pathHash !== pathHash.data) {
@@ -1483,18 +1617,20 @@ function createTransportEncryption(cryptoService, options) {
         const plaintext = openTransportPayload(cryptoService, authenticated, key.privateKey, clientPublicKey, bodyLimits);
         if (!plaintext.success)
           return plaintext;
-        const timeFailure = () => {
-          const error = new TransportTimeError(c);
+        const timeFailure = (serverTime) => {
+          const error = new TransportTimeError(c, serverTime);
           return err(HaiCryptoError.TRANSPORT_TIME_INVALID, error.message, error);
         };
         const now = Date.now();
-        if (c.issuedAt > now + TRANSPORT_PROTOCOL.CLOCK_SKEW_MS || now >= c.issuedAt + TRANSPORT_PROTOCOL.REQUEST_WINDOW_MS)
-          return timeFailure();
-        if (!await keyStore.claimRequest(c.clientId, c.requestId, c.issuedAt + TRANSPORT_PROTOCOL.REQUEST_WINDOW_MS + 2 * TRANSPORT_PROTOCOL.CLOCK_SKEW_MS)) {
+        const expiresAt = c.issuedAt + requestAgeMs;
+        if (c.issuedAt > now + futureSkewMs || now >= expiresAt)
+          return timeFailure(now);
+        if (!await keyStore.claimRequest(c.clientId, c.requestId, c.issuedAt + nonceRetentionMs)) {
           return transportAuthenticationFailure();
         }
-        if (Date.now() >= c.issuedAt + TRANSPORT_PROTOCOL.REQUEST_WINDOW_MS)
-          return timeFailure();
+        const claimedAt = Date.now();
+        if (claimedAt >= expiresAt)
+          return timeFailure(claimedAt);
         return plaintext;
       } catch {
         return transportAuthenticationFailure();
@@ -1511,6 +1647,7 @@ function createTransportEncryption(cryptoService, options) {
 var logger = core.logger.child({ module: "crypto", scope: "main" });
 var initialized = false;
 var initInProgress = false;
+var lifecycleGeneration = 0;
 var currentAsymmetric = null;
 var currentHash = null;
 var currentSymmetric = null;
@@ -1528,7 +1665,10 @@ function getCrypto() {
 }
 var transportOperations = {
   createServer: (options) => getCrypto().isInitialized ? createTransportEncryption(getCrypto(), options) : notInitialized.result(),
-  createClient: (options) => createTransportClient({ crypto: getCrypto(), ...options }),
+  createClient: (options) => createTransportClient({
+    crypto: getCrypto(),
+    ...options
+  }),
   protocol: TRANSPORT_PROTOCOL
 };
 var crypto2 = {
@@ -1545,15 +1685,24 @@ var crypto2 = {
       logger.warn("Crypto init already in progress, skipping concurrent call");
       return err(
         HaiCryptoError.INIT_FAILED,
-        cryptoM("crypto_initFailed", { params: { error: "Concurrent initialization detected" } })
+        cryptoM("crypto_initFailed", {
+          params: { error: "Concurrent initialization detected" }
+        })
       );
     }
     initInProgress = true;
+    const generation = ++lifecycleGeneration;
     try {
       await Promise.resolve();
+      if (generation !== lifecycleGeneration)
+        return notInitialized.result();
       if (initialized) {
         logger.warn("Crypto module is already initialized, reinitializing");
-        await crypto2.close();
+        currentAsymmetric = null;
+        currentHash = null;
+        currentSymmetric = null;
+        currentPassword = null;
+        initialized = false;
       }
       logger.info("Initializing crypto module");
       currentAsymmetric = createSM2();
@@ -1573,7 +1722,9 @@ var crypto2 = {
       return err(
         HaiCryptoError.INIT_FAILED,
         cryptoM("crypto_initFailed", {
-          params: { error: error instanceof Error ? error.message : String(error) }
+          params: {
+            error: error instanceof Error ? error.message : String(error)
+          }
         }),
         error
       );
@@ -1613,6 +1764,7 @@ var crypto2 = {
    * 关闭后访问 asymmetric/hash/symmetric/password 会返回 NOT_INITIALIZED 错误。
    */
   async close() {
+    lifecycleGeneration++;
     if (!initialized) {
       logger.info("Crypto module already closed, skipping");
       return;
@@ -1906,7 +2058,10 @@ function createReldbTransportKeyStore(options) {
   }
   async function pruneRows(tx) {
     let removed = 0;
-    for (const [table, id, expiry] of [[TRANSPORT_KEY_TABLE, "client_id", "expires_at_ms"], [TRANSPORT_REQUEST_TABLE, "request_key", "expires_at"]]) {
+    for (const [table, id, expiry] of [
+      [TRANSPORT_KEY_TABLE, "client_id", "expires_at_ms"],
+      [TRANSPORT_REQUEST_TABLE, "request_key", "expires_at"]
+    ]) {
       removed += unwrapResult2("tx.execute", await tx.execute(
         `DELETE FROM ${table} WHERE ${expiry} <= ${nowSql()} AND ${id} IN (SELECT ${id} FROM (SELECT ${id} FROM ${table} WHERE ${expiry} <= ${nowSql()} LIMIT ${PRUNE_BATCH_SIZE}) AS expired)`
       )).changes;
@@ -1961,7 +2116,10 @@ function createReldbTransportKeyStore(options) {
       const insertSql = options.reldb.config?.type === "mysql" ? `INSERT IGNORE INTO ${TRANSPORT_REQUEST_TABLE} (request_key, expires_at) VALUES (?, ?)` : `INSERT INTO ${TRANSPORT_REQUEST_TABLE} (request_key, expires_at) VALUES (?, ?) ON CONFLICT (request_key) DO NOTHING`;
       const inserted = unwrapResult2("reldb.sql.execute", await options.reldb.sql.execute(
         insertSql,
-        [JSON.stringify([clientId, requestId]), expiresAt]
+        [
+          JSON.stringify([clientId, requestId]),
+          expiresAt
+        ]
       ));
       return inserted.changes === 1;
     },
@@ -1973,6 +2131,6 @@ function createReldbTransportKeyStore(options) {
   };
 }
 
-export { HaiCryptoError, TRANSPORT_BODY_LIMITS, TRANSPORT_PLAINTEXT_RANGE, TRANSPORT_PROTOCOL, TransportBodyTooLargeError, TransportTimeError, authenticateTransportRequest, createInMemoryKeyStore, createRedisTransportKeyStore, createReldbTransportKeyStore, createTransportBodyPolicy, createTransportErrorResponse, crypto2 as crypto, isValidSM2PublicKey, parseTransportServerKeyRing, readTransportBody, resolveTransportBodyLimits };
+export { HaiCryptoError, TRANSPORT_BODY_LIMITS, TRANSPORT_PLAINTEXT_RANGE, TRANSPORT_PROTOCOL, TRANSPORT_TIME_LIMITS, TransportBodyTooLargeError, TransportTimeError, authenticateTransportRequest, createInMemoryKeyStore, createRedisTransportKeyStore, createReldbTransportKeyStore, createTransportBodyPolicy, createTransportErrorResponse, crypto2 as crypto, isValidSM2PublicKey, parseTransportServerKeyRing, readTransportBody, resolveTransportBodyLimits };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map