@h-ai/crypto 0.1.0-alpha.68 → 0.1.0-alpha.70

package/README.en.md

@@ -252,7 +252,11 @@ Only authenticated protocol v2 is accepted. Independent random SM4-CBC and HMAC-
 
 Empty POSTs still send an authenticated envelope for empty plaintext. GET/HEAD carry it in X-Hai-Transport; bodyless responses such as 204/304/HEAD use the same header. Other requests/responses carry a JSON envelope and X-Encrypted: true. The client must match the original request context and HTTP status; missing markers, old formats and authentication failures reject. Exclude plaintext endpoints explicitly with excludePaths. CORS must allow and expose X-Hai-Transport. TLS authenticates handshake keys; this protocol does not replace IAM authorization.
 
-serv, kit and the client share `TRANSPORT_BODY_LIMITS`: 16 KiB key exchange JSON, 4 KiB per public key, 1 MiB plaintext, and 2 MiB + 32 KiB encrypted JSON. All limits count actual UTF-8 bytes. Client key exchange has a 30-second timeout. Exceeding a limit, invalid UTF-8 or cancellation stops the original stream and releases its reader without cloning/teeing it. Caller signals remain active; cancelling one request does not cancel another request's shared handshake. Invalid encrypted responses reject instead of returning raw ciphertext.
+Set `transport.maxPlaintextBytes` for both request and response JSON plaintext, measured in UTF-8 bytes: default 1 MiB, integer range 1 KiB–64 MiB. Clients learn the server limit during key exchange. `resolveTransportBodyLimits()` derives encrypted/proxy bytes as twice the plaintext limit plus 32 KiB. Handshake, public-key, header and replay constraints remain independent. Oversized streams are cancelled and readers released: requests return 413; oversized responses return an encrypted 500 capacity error, recognized as `TransportBodyTooLargeError` / `hai:crypto:070`. [容量配置、文件换算与升级](TRANSPORT-CAPACITY.md)。
+
+serv/kit return an encrypted HTTP 400 time error for an out-of-window message only after request binding, signature and MAC verification. The client throws `TransportTimeError` (`hai:crypto:071`) with advice to synchronize device/server clocks and refresh. `api-client` maps it to `VALIDATION_FAILED` and preserves `cause.transportCode`. Requests are not replayed automatically and replay windows remain unchanged; tampered or unauthenticated messages retain the generic authentication failure.
+
+Custom HTTP adapters check `error instanceof TransportTimeError && error.context`, then encrypt the rejection with `createTransportErrorResponse(error, { manager, context: error.context })`. Never classify an unverified message by its timestamp.
 
 Custom HTTP adapters can import the pure `readTransportBody(stream, { maxBytes, signal? })` helper from the root entry without `crypto.init()`. Pass the original stream, rebuild Request/Response after reading, and clear stale Content-Length/Content-Encoding. The helper throws RangeError for byte limits, TypeError for invalid UTF-8, and preserves the original read/abort failure.
 

package/README.ja.md

@@ -252,7 +252,11 @@ const server = crypto.transport.createServer({ serverKeyRing, keyStore })
 
 空の POST も空平文の認証封装を送ります。GET/HEAD は X-Hai-Transport ヘッダー、204/304/HEAD など本文なし応答も同じヘッダーを使います。他の要求・応答は JSON 本文と X-Encrypted: true を使います。クライアントは元の要求コンテキストと HTTP status を照合し、マーカー欠落、旧形式、認証失敗では reject します。平文 endpoint は excludePaths で明示的に除外し、CORS では X-Hai-Transport を許可・公開してください。鍵交換の公開鍵認証は TLS に依存し、IAM の業務認可は別に必要です。
 
-serv、kit、クライアントは `TRANSPORT_BODY_LIMITS` を共有します。鍵交換 JSON は 16 KiB、公開鍵は 1 個あたり 4 KiB、平文は 1 MiB、暗号文 JSON は 2 MiB + 32 KiB です。すべて実際の UTF-8 バイト数で計算します。クライアントの鍵交換は最大 30 秒です。超過、不正 UTF-8、キャンセル時は元のストリームを停止して reader を解放し、clone/tee は作りません。呼び出し元の signal を維持し、1 件のキャンセルは他のリクエストと共有する鍵交換に影響しません。不正な暗号化応答は生の暗号文を返さず reject します。
+`transport.maxPlaintextBytes` でリクエストとレスポンスの JSON 平文容量を共通設定します。単位は UTF-8 バイト、既定値は 1 MiB、有効範囲は 1 KiB～64 MiB の整数です。クライアントは鍵交換で上限を取得し、`resolveTransportBodyLimits()` が暗号文とプロキシ容量（平文の 2 倍 + 32 KiB）を算出します。鍵交換、公開鍵、認証ヘッダー、防リプレイ制約は独立です。超過時は元ストリームを停止して reader を解放します。要求は 413、応答は暗号化された 500 容量エラーとなり、`TransportBodyTooLargeError` / `hai:crypto:070` で識別できます。 [容量配置、文件换算与升级](TRANSPORT-CAPACITY.md)。
+
+serv/kit は要求の結合、署名、MAC を検証した後、時間窓を超えた報文に暗号化した HTTP 400 時刻エラーを返します。クライアントは `TransportTimeError`（`hai:crypto:071`）で端末とサーバーの時刻同期・再読み込みを案内します。`api-client` は `VALIDATION_FAILED` に変換し `cause.transportCode` に原因を保持します。自動再送やリプレイ時間窓の緩和は行わず、改ざん・未認証の要求は従来の認証エラーです。
+
+独自 HTTP アダプターでは `error instanceof TransportTimeError && error.context` を確認し、`createTransportErrorResponse(error, { manager, context: error.context })` で拒否応答を暗号化します。未認証の報文のタイムスタンプだけで時刻異常を診断しないでください。
 
 独自 HTTP アダプターではルート入口の純粋関数 `readTransportBody(stream, { maxBytes, signal? })` を `crypto.init()` なしで利用できます。元のストリームを渡し、読み取り後は Request/Response を再構築して古い Content-Length/Content-Encoding を削除してください。上限超過は RangeError、不正 UTF-8 は TypeError、読み取り例外・signal.reason は元の理由で拒否します。ストリームのキャンセル処理が失敗しても元の例外を維持します。
 

package/README.md

@@ -252,7 +252,11 @@ const server = crypto.transport.createServer({ serverKeyRing, keyStore })
 
 空 POST 也发送空明文的认证封装；GET/HEAD 将封装放在 X-Hai-Transport 头，204/304/HEAD 等无正文响应也使用同名头承载认证封装。其它请求/响应在 JSON 正文承载封装并带 X-Encrypted: true。客户端必须关联原请求上下文和 HTTP status，缺标记、旧格式或认证失败一律 reject；明文接口只能经 excludePaths 显式排除。CORS 须允许并暴露 X-Hai-Transport。握手公钥的真实性依赖 TLS，不替代 IAM 业务授权。
 
-serv、kit 与客户端共享 `TRANSPORT_BODY_LIMITS`：握手 JSON 16 KiB，单个公钥 4 KiB，明文 1 MiB，密文 JSON 2 MiB + 32 KiB，均按实际 UTF-8 字节计算。客户端握手最多等待 30 秒；超限、无效 UTF-8 或取消会终止读取并释放 reader，不克隆/tee 原始正文。发送时保留调用方 signal；单个请求取消不会取消其它请求共享的握手。带加密标记的异常响应会 reject，不返回原始密文。
+业务容量通过 `transport.maxPlaintextBytes` 统一配置：默认 1 MiB，整数范围 1 KiB～64 MiB，请求和响应共用 UTF-8 明文字节预算。客户端从握手自动获取上限，密文与部署代理预算由 `resolveTransportBodyLimits()` 推导（两倍明文 + 32 KiB）。握手、公钥、认证头和防重放约束独立；超限取消原流并释放 reader，请求 413、响应为加密的 500 容量错误，客户端识别 `TransportBodyTooLargeError` / `hai:crypto:070`。 [容量配置、文件换算与升级](TRANSPORT-CAPACITY.md)。
+
+serv/kit 对通过请求绑定、签名和 MAC 校验但超出时间窗口的报文返回加密的 HTTP 400 时间错误；客户端抛 `TransportTimeError`（`hai:crypto:071`），提示同步设备和服务器时间后刷新重试。`api-client` 映射为 `VALIDATION_FAILED`，在 `cause.transportCode` 保留该原因。不会自动重放请求或放宽防重放窗口；篡改或未认证报文仍返回通用认证失败。
+
+自定义 HTTP 适配器检查失败原因 `error instanceof TransportTimeError && error.context` 后，使用 `createTransportErrorResponse(error, { manager, context: error.context })` 加密拒绝响应；不能根据未认证报文的时间戳给出可信时间诊断。
 
 自定义 HTTP 适配器可从根入口使用纯工具 `readTransportBody(stream, { maxBytes, signal? })`，无需 `crypto.init()`。必须传入原始流；读取成功后重建 Request/Response，并清理旧 Content-Length/Content-Encoding。此工具对超限抛 RangeError，对无效 UTF-8 抛 TypeError，保留读取异常或 signal.reason；流取消清理失败不覆盖原异常。
 

package/dist/index.d.ts

@@ -4,13 +4,121 @@ import { CacheFunctions } from '@h-ai/cache';
 import { ReldbFunctions } from '@h-ai/reldb';
 
 /**
- * @h-ai/crypto — 传输加密类型与协议常量
+ * @h-ai/crypto — 传输协议的字节预算与有界正文读取。
  *
- * 提供 SM2 + SM4（或等效非对称 + 对称）混合传输加密所需的接口与协议常量，
- * 由 kit / serv / api-client 共享，确保两端协议完全一致。
+ * serv/kit 共享相同预算，不依赖可省略或伪造的 Content-Length。
+ * @module crypto-transport-body
+ */
+/**
+ * 传输预算；业务预算由明文容量推导，安全字段保持独立。
+ * @example
+ * ```ts
+ * import { resolveTransportBodyLimits, type TransportBodyLimits } from '@h-ai/crypto'
+ * const limits: TransportBodyLimits = resolveTransportBodyLimits(8 * 1024 * 1024)
+ * const proxyBytes = limits.encryptedPayloadBytes
+ * ```
+ */
+interface TransportBodyLimits {
+    readonly keyExchangeBytes: number;
+    readonly envelopeHeaderBytes: number;
+    readonly publicKeyBytes: number;
+    readonly plaintextBytes: number;
+    readonly encryptedPayloadBytes: number;
+}
+/**
+ * 业务明文的有效 UTF-8 字节范围：1 KiB～64 MiB；不支持无限制。
+ * @example
+ * ```ts
+ * import { TRANSPORT_PLAINTEXT_RANGE } from '@h-ai/crypto'
+ * const maximumBytes = TRANSPORT_PLAINTEXT_RANGE.max
+ * ```
+ */
+declare const TRANSPORT_PLAINTEXT_RANGE: Readonly<{
+    min: 1024;
+    max: number;
+}>;
+/**
+ * 默认UTF-8字节预算；按实际流读取，不依赖Content-Length，非字符串字符数限制。
+ *
+ * @example
+ * ```ts
+ * import { readTransportBody, TRANSPORT_BODY_LIMITS } from '@h-ai/crypto'
+ * const request = new Request('https://api.example.com/api/v1/orders', { method: 'POST', body: JSON.stringify({ message: 'hello' }) })
+ * const text = await readTransportBody(request.body, { maxBytes: TRANSPORT_BODY_LIMITS.plaintextBytes, signal: request.signal })
+ * ```
+ */
+declare const TRANSPORT_BODY_LIMITS: TransportBodyLimits;
+/**
+ * 校验单一业务明文容量并推导双向密文预算；返回不可变快照。
+ * SM4-CBC 使用十六进制编码，预算为明文的两倍加 32 KiB（填充及认证封装）。
+ * @param maxPlaintextBytes - UTF-8 字节数，默认 1 MiB，有效范围 1 KiB～64 MiB 的整数。
+ * @returns 明文、密文及独立安全预算。
+ * @throws RangeError - 配置无效；不接受字符串、null、无限制或静默回退。
+ * @example
+ * ```ts
+ * import { resolveTransportBodyLimits } from '@h-ai/crypto'
+ * const limits = resolveTransportBodyLimits(8 * 1024 * 1024)
+ * const nginxLimit = limits.encryptedPayloadBytes
+ * ```
+ */
+declare function resolveTransportBodyLimits(maxPlaintextBytes?: number): TransportBodyLimits;
+/**
+ * 可识别的容量错误；只包含方向、阶段和字节数，不包含报文内容。
+ * @example
+ * ```ts
+ * import { TransportBodyTooLargeError } from '@h-ai/crypto'
+ * const error = new TransportBodyTooLargeError(1024, 1025, { direction: 'request', stage: 'plaintext' })
+ * const diagnostic = { code: error.code, limitBytes: error.limitBytes, actualBytes: error.actualBytes }
+ * ```
+ */
+declare class TransportBodyTooLargeError extends RangeError {
+    readonly code: string | number;
+    readonly direction: 'request' | 'response';
+    readonly stage: 'plaintext' | 'encrypted' | 'header';
+    readonly limitBytes: number;
+    readonly actualBytes?: number;
+    constructor(limitBytes: number, actualBytes?: number, options?: {
+        direction?: 'request' | 'response';
+        stage?: 'plaintext' | 'encrypted' | 'header';
+    });
+}
+/**
+ * 有界原流读取选项；maxBytes是非负安全整数，signal取消等待和底层流。
  *
- * @module crypto-transport-types
+ * @example
+ * ```ts
+ * import { readTransportBody, type ReadTransportBodyOptions } from '@h-ai/crypto'
+ * const request = new Request('https://api.example.com/api/v1/orders', { method: 'POST', body: 'hello' })
+ * const options: ReadTransportBodyOptions = { maxBytes: 1024, signal: request.signal }
+ * const text = await readTransportBody(request.body, options)
+ * ```
  */
+interface ReadTransportBodyOptions {
+    /** 允许读取的字节总数，必须为非负安全整数。 */
+    readonly maxBytes: number;
+    /** 请求取消时中止等待中的读取并取消底层流。 */
+    readonly signal?: AbortSignal;
+    /** 超限诊断方向；默认 request。 */
+    readonly direction?: 'request' | 'response';
+    /** 超限诊断阶段；默认 plaintext。 */
+    readonly stage?: 'plaintext' | 'encrypted' | 'header';
+}
+/**
+ * 逐块读取原始字节流并严格UTF-8解码；超限/取消后取消流并释放reader，清理失败不覆盖原异常。
+ * 不要传入clone/tee分支，否则另一分支仍可能保留数据。
+ * @param stream - 原始流；null返回空串但仍检查取消。
+ * @param options - 字节预算与取消信号。
+ * @returns 解码文本。
+ * @throws RangeError预算无效或超限；非法UTF-8、流异常和signal.reason继续抛出。
+ *
+ * @example
+ * ```ts
+ * import { readTransportBody } from '@h-ai/crypto'
+ * const request = new Request('https://api.example.com/api/v1/orders', { method: 'POST', body: 'hello' })
+ * const text = await readTransportBody(request.body, { maxBytes: 1024, signal: request.signal })
+ * ```
+ */
+declare function readTransportBody(stream: ReadableStream<Uint8Array> | null, options: ReadTransportBodyOptions): Promise<string>;
 
 /**
  * 认证传输v2的头名、窗口与默认协商子路径；各HTTP适配器共用，不手写漂移常量。
@@ -75,6 +183,8 @@ interface KeyExchangeRequest {
  * ```
  */
 interface KeyExchangeResponse {
+    /** 服务端业务明文 UTF-8 字节上限；缺省表示旧服务端的 1 MiB 默认值。 */
+    readonly maxPlaintextBytes?: number;
     /** 服务端当前加密密钥版本；业务请求必须带回该值。 */
     readonly serverKeyId: string;
     readonly serverPublicKey: string;
@@ -436,6 +546,8 @@ interface TransportKeyStore {
  * ```
  */
 interface TransportCreateServerOptions {
+    /** 双向业务明文 UTF-8 字节上限；默认 1 MiB，整数范围 1 KiB～64 MiB。 */
+    readonly maxPlaintextBytes?: number;
     /** 必填受管服务端密钥环；没有隐式随机生成或进程密钥回退。 */
     readonly serverKeyRing: TransportServerKeyRing;
     /** 客户端公钥存储；生产必须注入跨节点共享实现。 */
@@ -473,6 +585,8 @@ interface TransportCreateServerOptions {
  * ```
  */
 interface TransportEncryptionManager {
+    /** 本管理器不可变的双向预算；由 maxPlaintextBytes 推导，安全预算独立。 */
+    readonly bodyLimits: TransportBodyLimits;
     /**
      * 当前新协商使用的服务端密钥 ID。
      * @returns 直接返回值，使用前先初始化模块。
@@ -739,6 +853,8 @@ declare const HaiCryptoError: {
     readonly HASH_FAILED: _h_ai_core.HaiErrorDef;
     readonly HMAC_FAILED: _h_ai_core.HaiErrorDef;
     readonly INVALID_IV: _h_ai_core.HaiErrorDef;
+    readonly TRANSPORT_PAYLOAD_TOO_LARGE: _h_ai_core.HaiErrorDef;
+    readonly TRANSPORT_TIME_INVALID: _h_ai_core.HaiErrorDef;
 };
 /**
  * SM2 密文排列：1为C1C3C2默认值，0为显式C1C2C3；解密必须匹配加密排列。
@@ -1648,6 +1764,7 @@ interface TransportOperations {
      * @param options - 实际调用输入，按该方法约束验证。
      * @param options.keyExchangeUrl - 密钥协商端点完整 URL。
      * @param options.fetch - 实际发送 HTTP 请求的 fetch，默认 `globalThis.fetch`。
+     * @param options.maxPlaintextBytes - 可选本地明文 UTF-8 字节上限，默认跟随服务端。
      * @returns 直接返回值，使用前先初始化模块。
      *
      * @example
@@ -1671,6 +1788,7 @@ interface TransportOperations {
     createClient: (options: {
         keyExchangeUrl: string;
         fetch?: typeof fetch;
+        maxPlaintextBytes?: number;
     }) => TransportClient;
     /** 协议常量（headers、密钥协商默认路径）。 */
     readonly protocol: typeof TRANSPORT_PROTOCOL;
@@ -1795,67 +1913,40 @@ declare const crypto: CryptoFunctions;
  */
 declare function isValidSM2PublicKey(publicKey: unknown): publicKey is string;
 
+/** @h-ai/crypto — serv/kit 共用的安全传输错误响应。 */
+
 /**
- * @h-ai/crypto — 传输协议的字节预算与有界正文读取。
- *
- * serv/kit 共享相同预算，不依赖可省略或伪造的 Content-Length。
- * @module crypto-transport-body
- */
-/**
- * 协议固定UTF-8字节预算；按实际流读取，不依赖Content-Length，非字符串字符数限制。
- *
- * @example
- * ```ts
- * import { readTransportBody, TRANSPORT_BODY_LIMITS } from '@h-ai/crypto'
- * const request = new Request('https://api.example.com/api/v1/orders', { method: 'POST', body: JSON.stringify({ message: 'hello' }) })
- * const text = await readTransportBody(request.body, { maxBytes: TRANSPORT_BODY_LIMITS.plaintextBytes, signal: request.signal })
- * ```
- */
-declare const TRANSPORT_BODY_LIMITS: {
-    /** 密钥协商 JSON 的 UTF-8 总字节数。 */
-    readonly keyExchangeBytes: 16384;
-    /** GET/HEAD 请求及无正文响应的认证头封装 UTF-8 上限。 */
-    readonly envelopeHeaderBytes: 16384;
-    /** 单个协商公钥的 UTF-8 字节数。 */
-    readonly publicKeyBytes: 4096;
-    /** 解密后的请求/加密前的响应明文字节数。 */
-    readonly plaintextBytes: 1048576;
-    /** 密文 JSON 的 UTF-8 总字节数（2 MiB + 32 KiB，含 CBC 填充与全部认证字段）。 */
-    readonly encryptedPayloadBytes: 2129920;
-};
-/**
- * 有界原流读取选项；maxBytes是非负安全整数，signal取消等待和底层流。
- *
+ * 已认证请求的时间窗口错误；只提供校时建议，不调整时钟或放宽防重放窗口。
  * @example
  * ```ts
- * import { readTransportBody, type ReadTransportBodyOptions } from '@h-ai/crypto'
- * const request = new Request('https://api.example.com/api/v1/orders', { method: 'POST', body: 'hello' })
- * const options: ReadTransportBodyOptions = { maxBytes: 1024, signal: request.signal }
- * const text = await readTransportBody(request.body, options)
+ * import { TransportTimeError } from '@h-ai/crypto'
+ * const error = new TransportTimeError()
+ * // 展示 error.message；同步设备/服务器时间后由用户刷新重试。
  * ```
  */
-interface ReadTransportBodyOptions {
-    /** 允许读取的字节总数，必须为非负安全整数。 */
-    readonly maxBytes: number;
-    /** 请求取消时中止等待中的读取并取消底层流。 */
-    readonly signal?: AbortSignal;
+declare class TransportTimeError extends Error {
+    readonly context?: TransportMessageContext | undefined;
+    readonly code: string | number;
+    constructor(context?: TransportMessageContext | undefined);
 }
 /**
- * 逐块读取原始字节流并严格UTF-8解码；超限/取消后取消流并释放reader，清理失败不覆盖原异常。
- * 不要传入clone/tee分支，否则另一分支仍可能保留数据。
- * @param stream - 原始流；null返回空串但仍检查取消。
- * @param options - 字节预算与取消信号。
- * @returns 解码文本。
- * @throws RangeError预算无效或超限；非法UTF-8、流异常和signal.reason继续抛出。
- *
+ * 创建脱敏传输错误；已验证绑定、签名和 MAC 的时间/响应容量错误继续加密，请求读取超限返回 HTTP 413。
+ * @param error - 容量或时间错误，不包含业务报文。
+ * @param authenticated - 仅在请求绑定、签名和 MAC 已验证后提供管理器和上下文。
+ * @param authenticated.manager - 使用原服务端预算的管理器。
+ * @param authenticated.context - 已验证请求绑定、签名和 MAC 的上下文；时间拒绝不会放行业务。
+ * @returns 可诊断的失败响应；加密失败仍只返回错误，不发送原业务响应。
  * @example
  * ```ts
- * import { readTransportBody } from '@h-ai/crypto'
- * const request = new Request('https://api.example.com/api/v1/orders', { method: 'POST', body: 'hello' })
- * const text = await readTransportBody(request.body, { maxBytes: 1024, signal: request.signal })
+ * import { createTransportErrorResponse, TransportBodyTooLargeError } from '@h-ai/crypto'
+ * const response = await createTransportErrorResponse(new TransportBodyTooLargeError(1024, 1025))
+ * const status = response.status // 413
  * ```
  */
-declare function readTransportBody(stream: ReadableStream<Uint8Array> | null, options: ReadTransportBodyOptions): Promise<string>;
+declare function createTransportErrorResponse(error: TransportBodyTooLargeError | TransportTimeError, authenticated?: {
+    manager: TransportEncryptionManager;
+    context: TransportMessageContext;
+}): Promise<Response>;
 
 /**
  * @h-ai/crypto — 服务端受管传输密钥环的安全解析。
@@ -2096,4 +2187,4 @@ interface ReldbTransportKeyStore extends TransportKeyStore {
  */
 declare function createReldbTransportKeyStore(options: CreateReldbTransportKeyStoreOptions): ReldbTransportKeyStore;
 
-export { type AsymmetricEncryptOptions, type AsymmetricOperations, type CipherMode, type CreateRedisTransportKeyStoreOptions, type CreateReldbTransportKeyStoreOptions, type CryptoFunctions, type EncryptWithIVResult, type EncryptedPayload, type EncryptedRequestPayload, HaiCryptoError, type HashOperations, type HashOptions, type KeyExchangeRequest, type KeyExchangeResponse, type KeyPair, type PasswordConfig, type PasswordOperations, type ReadTransportBodyOptions, type ReldbTransportKeyStore, type SignOptions, type SymmetricCbcEncryptedPayload, type SymmetricCiphertextEncoding, type SymmetricDecryptInput, type SymmetricEncryptOptions, type SymmetricEncryptedPayload, type SymmetricMode, type SymmetricOperations, TRANSPORT_BODY_LIMITS, TRANSPORT_PROTOCOL, type TransportClient, type TransportCreateServerOptions, type TransportCryptoServiceLike, type TransportEncryptionManager, type TransportKeyPair, type TransportKeyStore, type TransportMessageContext, type TransportOperations, type TransportRequestContext, type TransportServerKeyRing, authenticateTransportRequest, createInMemoryKeyStore, createRedisTransportKeyStore, createReldbTransportKeyStore, crypto, isValidSM2PublicKey, parseTransportServerKeyRing, readTransportBody };
+export { type AsymmetricEncryptOptions, type AsymmetricOperations, type CipherMode, type CreateRedisTransportKeyStoreOptions, type CreateReldbTransportKeyStoreOptions, type CryptoFunctions, type EncryptWithIVResult, type EncryptedPayload, type EncryptedRequestPayload, HaiCryptoError, type HashOperations, type HashOptions, type KeyExchangeRequest, type KeyExchangeResponse, type KeyPair, type PasswordConfig, type PasswordOperations, type ReadTransportBodyOptions, type ReldbTransportKeyStore, type SignOptions, type SymmetricCbcEncryptedPayload, type SymmetricCiphertextEncoding, type SymmetricDecryptInput, type SymmetricEncryptOptions, type SymmetricEncryptedPayload, type SymmetricMode, type SymmetricOperations, TRANSPORT_BODY_LIMITS, TRANSPORT_PLAINTEXT_RANGE, TRANSPORT_PROTOCOL, type TransportBodyLimits, TransportBodyTooLargeError, type TransportClient, type TransportCreateServerOptions, type TransportCryptoServiceLike, type TransportEncryptionManager, type TransportKeyPair, type TransportKeyStore, type TransportMessageContext, type TransportOperations, type TransportRequestContext, type TransportServerKeyRing, TransportTimeError, authenticateTransportRequest, createInMemoryKeyStore, createRedisTransportKeyStore, createReldbTransportKeyStore, createTransportErrorResponse, crypto, isValidSM2PublicKey, parseTransportServerKeyRing, readTransportBody, resolveTransportBodyLimits };