@agentunion/fastaun 0.5.21 → 0.5.23

package/dist/auth.js

@@ -348,7 +348,7 @@ function _strictCrlRevokedSerials(pem, issuer, now) {
                 throw new AuthError('service event CRL entry is invalid');
             revoked.add(serial.content.toString('hex').replace(/^0+/, '') || '0');
         }
-    return revoked;
+    return { revokedSerials: revoked, nextRefreshAt: nextUpdate * 1000 };
 }
 function _verifyOwnershipOcsp(der, certificate, issuer, now) {
     const outer = _ownershipDer(der);
@@ -405,6 +405,7 @@ function _verifyOwnershipOcsp(der, certificate, issuer, now) {
         throw new StateError('OCSP response is not current', { stringCode: 'unavailable', retryable: true });
     const responses = _ownershipDerChildren(tbs[offset++], 0x30);
     let status;
+    let nextRefreshAt = 0;
     for (const entry of responses) {
         const single = _ownershipDerChildren(entry, 0x30);
         if (single.length < 4)
@@ -425,6 +426,7 @@ function _verifyOwnershipOcsp(der, certificate, issuer, now) {
         if (single[3].tag !== 0xa0)
             throw new StateError('OCSP nextUpdate is missing', { stringCode: 'unavailable', retryable: true });
         const nextUpdate = _ownershipOcspTime(_ownershipDerChildren(single[3])[0]);
+        nextRefreshAt = nextUpdate * 1000;
         if (thisUpdate > now + 5 || thisUpdate < now - 30 || nextUpdate <= now || nextUpdate <= thisUpdate)
             throw new StateError('OCSP validity window is not current', { stringCode: 'unavailable', retryable: true });
         if (single[1].tag === 0x80 && single[1].content.length === 0)
@@ -438,7 +440,7 @@ function _verifyOwnershipOcsp(der, certificate, issuer, now) {
     }
     if (!status)
         throw new ValidationError('OCSP does not match the requested certificate', { stringCode: 'invalid' });
-    return status;
+    return { status, nextRefreshAt };
 }
 // ── HTTP 辅助 ─────────────────────────────────────────────────
 /** 将 WebSocket URL 转换为 HTTP URL + 路径 */
@@ -531,16 +533,21 @@ export class AuthFlow {
     _rootCerts;
     // Gateway CA 链缓存：gateway_url -> PEM 字符串数组
     _gatewayChainCache = new Map();
+    _gatewayChainLoads = new Map();
     // Gateway CRL 缓存：gateway_url -> CRL 缓存条目
     _gatewayCrlCache = new Map();
     // Gateway OCSP 缓存：gateway_url -> (serial_hex -> OCSP 缓存条目)
     _gatewayOcspCache = new Map();
-    // 证书链验证结果缓存：cert_serial -> verified_at (ms)
+    // 证书链验证结果缓存：材料与用途 -> expires_at (ms)
     _chainVerifiedCache = new Map();
+    _strictPkiCache = new Map();
+    _peerPkiCache = new Map();
+    _strictPkiEpoch = 0;
     // Gateway CA 链预验证标记：cache_key -> verified
     _gatewayCaVerified = new Map();
     // 调用方注入的内存私钥（由 AUNClient.loadIdentity 传入，不走 tokenStore 解密）
     _memIdentity = null;
+    _identityPkiContext = '';
     constructor(opts) {
         this._logger = opts.logger ?? _noopLogger;
         this._tokenStore = opts.tokenStore;
@@ -552,7 +559,7 @@ export class AuthFlow {
         this._rootCaPath = opts.rootCaPath ?? null;
         this._net = opts.net ?? null;
         this._verifySsl = opts.verifySsl ?? false;
-        this._chainCacheTtl = (opts.chainCacheTtl ?? 86400) * 1000; // 转为毫秒
+        this._chainCacheTtl = Math.min(opts.chainCacheTtl ?? 3600, 3600) * 1000; // 转为毫秒
         this._rootCerts = this._loadRootCerts(this._rootCaPath);
     }
     // ── 公开方法 ────────────────────────────────────────────────
@@ -561,6 +568,10 @@ export class AuthFlow {
      * AuthFlow 内部不再从 tokenStore 解密私钥，只使用此处注入的明文。
      */
     setIdentity(identity) {
+        const context = JSON.stringify([identity?.aid ?? '', identity?.cert ?? '']);
+        if (this._identityPkiContext !== context)
+            this.invalidateStrictPkiCache();
+        this._identityPkiContext = context;
         this._memIdentity = identity;
         if (identity?.aid)
             this._aid = String(identity.aid);
@@ -936,7 +947,13 @@ export class AuthFlow {
             const nowMs = Date.now();
             _ensureCertTimeValid(cert, 'peer certificate', nowMs);
             if (strictRevocation) {
-                const chain = (await this._fetchGatewayCaChain(gatewayUrl, expectedAid, true)).map(_loadX509);
+                const epoch = this._strictPkiEpoch;
+                const cacheKey = JSON.stringify([gatewayUrl, expectedAid, cert.fingerprint256, this._loadTrustedRoots().map((root) => root.fingerprint256)]);
+                const cached = this._strictPkiCache.get(cacheKey);
+                if (cached && cached.epoch === epoch && cached.status === 'good' && cached.expiresAt > Date.now())
+                    return;
+                this._strictPkiCache.delete(cacheKey);
+                const chain = await this._loadGatewayCaChain(gatewayUrl, expectedAid, false, true);
                 if (!chain.length)
                     throw new AuthError('service event certificate chain is unavailable');
                 const current = Math.trunc(Date.now() / 1000);
@@ -946,12 +963,26 @@ export class AuthFlow {
                 const crl = await this._fetchGatewayCrl(gatewayUrl, chain[0], true);
                 if (crl.revokedSerials.has(_certSerialHex(cert)))
                     throw new AuthError('service event certificate has been revoked');
-                await this._fetchGatewayOcspStatus(gatewayUrl, cert, chain[0], true);
+                const ocsp = await this._fetchGatewayOcspStatus(gatewayUrl, cert, chain[0], true);
                 if (_certSubjectCN(cert) !== expectedAid)
                     throw new AuthError(`peer cert CN mismatch: expected ${expectedAid}`);
+                const expiresAt = Math.min(tStart + 3600_000, Date.parse(cert.validTo), ...chain.map((ca) => Date.parse(ca.validTo)), crl.nextRefreshAt, ocsp.nextRefreshAt);
+                if (epoch === this._strictPkiEpoch && expiresAt > Date.now()) {
+                    this.cleanExpiredCaches();
+                    if (this._strictPkiCache.size >= 2048)
+                        this._strictPkiCache.delete(this._strictPkiCache.keys().next().value);
+                    this._strictPkiCache.set(cacheKey, { epoch, expiresAt, status: ocsp.status });
+                }
                 return;
             }
+            const epoch = this._strictPkiEpoch;
+            const cacheKey = JSON.stringify([gatewayUrl, expectedAid, cert.fingerprint256, this._loadTrustedRoots().map((root) => root.fingerprint256)]);
+            const cached = this._peerPkiCache.get(cacheKey);
+            if (cached && cached.epoch === epoch && cached.expiresAt > Date.now())
+                return;
+            this._peerPkiCache.delete(cacheKey);
             await this._verifyAuthCertChain(gatewayUrl, cert, expectedAid);
+            let revocationChecked = true;
             try {
                 await this._verifyAuthCertRevocation(gatewayUrl, cert, expectedAid);
             }
@@ -959,6 +990,7 @@ export class AuthFlow {
                 const errMsg = e instanceof Error ? e.message : String(e);
                 if (/revoked/i.test(errMsg))
                     throw e instanceof AuthError ? e : new AuthError(errMsg);
+                revocationChecked = false;
                 this._logger.warn(`CRL verification unavailable, skipping: ${errMsg}`);
             }
             try {
@@ -968,6 +1000,7 @@ export class AuthFlow {
                 const errMsg = exc instanceof Error ? exc.message : String(exc);
                 if (/revoked/i.test(errMsg))
                     throw exc instanceof AuthError ? exc : new AuthError(errMsg);
+                revocationChecked = false;
                 this._logger.warn(`OCSP verification unavailable, skipping: ${errMsg}`);
             }
             // 检查 CN 匹配
@@ -975,6 +1008,20 @@ export class AuthFlow {
             if (cn !== expectedAid) {
                 throw new AuthError(`peer cert CN mismatch: expected ${expectedAid}, got ${cn || 'none'}`);
             }
+            if (revocationChecked && epoch === this._strictPkiEpoch) {
+                const chain = this._gatewayChainCache.get(`${gatewayUrl}:${expectedAid}`);
+                const crl = this._gatewayCrlCache.get(gatewayUrl);
+                const ocsp = this._gatewayOcspCache.get(gatewayUrl)?.get(_certSerialHex(cert));
+                if (chain && crl && ocsp) {
+                    const expiresAt = Math.min(tStart + 3600_000, Date.parse(cert.validTo), chain.expiresAt, crl.nextRefreshAt, ocsp.nextRefreshAt);
+                    if (expiresAt > Date.now()) {
+                        this.cleanExpiredCaches();
+                        if (this._peerPkiCache.size >= 2048)
+                            this._peerPkiCache.delete(this._peerPkiCache.keys().next().value);
+                        this._peerPkiCache.set(cacheKey, { epoch, expiresAt });
+                    }
+                }
+            }
             this._logger.debug(`verifyPeerCertificate exit: elapsed=${Date.now() - tStart}ms aid=${expectedAid}`);
         }
         catch (err) {
@@ -983,6 +1030,7 @@ export class AuthFlow {
         }
     }
     async resolveCurrentEntityCertificate(gatewayUrl, aid, type) {
+        const began = Date.now();
         try {
             const query = new URLSearchParams({ consistency: 'authoritative', ...(type === 'group' ? { key_purpose: 'group_identity' } : {}) });
             const response = await this._fetchOwnershipPki(_gatewayHttpUrl(gatewayUrl, `/pki/cert/${encodeURIComponent(aid)}?${query}`));
@@ -996,7 +1044,7 @@ export class AuthFlow {
             catch {
                 throw new ValidationError('entity current certificate is invalid', { stringCode: 'invalid' });
             }
-            return this.resolveOwnershipCertificate(gatewayUrl, aid, fingerprint, type === 'group' ? 'group_identity' : 'signing');
+            return this._verifyOwnershipCertificate(gatewayUrl, aid, fingerprint, response, began);
         }
         catch (error) {
             if (error instanceof AUNError && error.stringCode)
@@ -1014,6 +1062,21 @@ export class AuthFlow {
             if (purpose === 'group_identity')
                 query.set('key_purpose', purpose);
             const response = await this._fetchOwnershipPki(_gatewayHttpUrl(gatewayUrl, `/pki/cert/${encodeURIComponent(aid)}?${query}`));
+            return await this._verifyOwnershipCertificate(gatewayUrl, aid, fingerprint, response, began);
+        }
+        catch (error) {
+            if (error instanceof ValidationError)
+                throw new ValidationError(error.message, { stringCode: 'invalid' });
+            if (error instanceof StateError && error.stringCode)
+                throw error;
+            throw unavailable(error instanceof Error ? error.message : String(error));
+        }
+    }
+    async _verifyOwnershipCertificate(gatewayUrl, aid, fingerprint, response, began) {
+        const unavailable = (reason) => new StateError(reason, { stringCode: 'unavailable', retryable: true });
+        try {
+            if (!/^[a-z0-9_][a-z0-9_-]*(?:\.[a-z0-9_][a-z0-9_-]*)+$/.test(aid) || !/^sha256:[0-9a-f]{64}$/.test(fingerprint))
+                throw new ValidationError('ownership certificate query requires exact AID and full fingerprint', { stringCode: 'invalid' });
             if (response.status !== 200)
                 throw unavailable(`ownership certificate HTTP ${response.status}`);
             const headers = response.headers;
@@ -1040,30 +1103,12 @@ export class AuthFlow {
             validateAgentMdCertificate(response.body, aid, Math.trunc(now), { now: Math.trunc(now), requireCurrentValidity: true });
             if (certFingerprint(response.body) !== fingerprint)
                 throw new ValidationError('ownership certificate DER fingerprint mismatch', { stringCode: 'invalid' });
-            const chainResponse = await this._fetchOwnershipPki(_gatewayHttpUrl(gatewayUrl, `/pki/chain/${encodeURIComponent(aid)}`));
-            if (chainResponse.status !== 200 || !chainResponse.body.trim())
-                throw unavailable('ownership certificate chain is unavailable');
-            let chain;
-            try {
-                chain = _splitPemBundle(chainResponse.body).map(_loadX509);
-            }
-            catch {
-                throw new ValidationError('ownership certificate chain PEM is invalid', { stringCode: 'invalid' });
-            }
+            const epoch = this._strictPkiEpoch;
+            const chain = [...await this._loadGatewayCaChain(gatewayUrl, aid, true)];
             if (chain[0] && !chain[0].ca && _certSubjectCN(chain[0]) === aid)
                 chain.shift();
             if (!chain.length)
                 throw unavailable('ownership issuer chain is unavailable');
-            let current = cert;
-            for (let index = 0; index < chain.length; index++) {
-                const issuer = chain[index];
-                const constraints = _ownershipCertConstraints(issuer);
-                if (constraints.pathLen !== undefined && index > constraints.pathLen)
-                    throw new ValidationError('ownership certificate path length is invalid', { stringCode: 'invalid' });
-                if (!constraints.basicPresent || !issuer.ca || !constraints.keyUsagePresent || !constraints.keyCertSign || Date.now() < Date.parse(issuer.validFrom) || Date.now() > Date.parse(issuer.validTo) || !current.checkIssued(issuer) || !current.verify(issuer.publicKey))
-                    throw new ValidationError('ownership certificate chain is invalid', { stringCode: 'invalid' });
-                current = issuer;
-            }
             let roots;
             try {
                 roots = this._loadTrustedRoots();
@@ -1071,8 +1116,23 @@ export class AuthFlow {
             catch {
                 throw unavailable('ownership trust anchors are unavailable');
             }
-            if (!current.checkIssued(current) || !current.verify(current.publicKey) || !roots.some((root) => root.raw.equals(current.raw)))
-                throw new ValidationError('ownership certificate chain is not anchored by a trusted root', { stringCode: 'invalid' });
+            const staticKey = JSON.stringify(['ownership', gatewayUrl, aid, cert.fingerprint256, chain.map((item) => item.fingerprint256), roots.map((root) => root.fingerprint256)]);
+            if ((this._chainVerifiedCache.get(staticKey) ?? 0) <= Date.now()) {
+                let current = cert;
+                for (let index = 0; index < chain.length; index++) {
+                    const issuer = chain[index];
+                    const constraints = _ownershipCertConstraints(issuer);
+                    if (constraints.pathLen !== undefined && index > constraints.pathLen)
+                        throw new ValidationError('ownership certificate path length is invalid', { stringCode: 'invalid' });
+                    if (!constraints.basicPresent || !issuer.ca || !constraints.keyUsagePresent || !constraints.keyCertSign || Date.now() < Date.parse(issuer.validFrom) || Date.now() > Date.parse(issuer.validTo) || !current.checkIssued(issuer) || !current.verify(issuer.publicKey))
+                        throw new ValidationError('ownership certificate chain is invalid', { stringCode: 'invalid' });
+                    current = issuer;
+                }
+                if (!current.checkIssued(current) || !current.verify(current.publicKey) || !roots.some((root) => root.raw.equals(current.raw)))
+                    throw new ValidationError('ownership certificate chain is not anchored by a trusted root', { stringCode: 'invalid' });
+                if (epoch === this._strictPkiEpoch)
+                    this._chainVerifiedCache.set(staticKey, Math.min(Date.now() + this._chainCacheTtl, Date.parse(cert.validTo), ...chain.map((item) => Date.parse(item.validTo))));
+            }
             const ocspResponse = await this._fetchOwnershipPki(_gatewayHttpUrl(gatewayUrl, `/pki/ocsp/${cert.serialNumber.toLowerCase()}`));
             if (ocspResponse.status !== 200)
                 throw unavailable('ownership OCSP is unavailable');
@@ -1093,7 +1153,7 @@ export class AuthFlow {
                 throw new ValidationError('ownership OCSP Base64 is invalid', { stringCode: 'invalid' });
             let status;
             try {
-                status = _verifyOwnershipOcsp(Buffer.from(ocsp.ocsp_response, 'base64'), cert, chain[0], Date.now() / 1000);
+                status = _verifyOwnershipOcsp(Buffer.from(ocsp.ocsp_response, 'base64'), cert, chain[0], Date.now() / 1000).status;
             }
             catch (error) {
                 if (error instanceof ValidationError || error instanceof StateError)
@@ -1169,17 +1229,16 @@ export class AuthFlow {
             .filter((pem) => pem.length > 0);
         if (normalized.length === 0)
             return;
-        for (const pem of normalized)
-            _loadX509(pem);
+        const chain = normalized.map(_loadX509);
         const cacheKey = chainAid ? `${gatewayUrl}:${chainAid}` : gatewayUrl;
-        this._gatewayChainCache.set(cacheKey, normalized);
-        this._gatewayCaVerified.delete(cacheKey);
+        const previous = this._gatewayChainCache.get(cacheKey);
+        if (previous && JSON.stringify(previous.chain.map((pem) => _loadX509(pem).fingerprint256)) !== JSON.stringify(chain.map((cert) => cert.fingerprint256)))
+            this.invalidateStrictPkiCache();
+        this._gatewayChainCache.set(cacheKey, { chain: normalized, expiresAt: Math.min(Date.now() + 3600_000, ...chain.map((cert) => Date.parse(cert.validTo))) });
     }
     /** 丢弃预置或缓存的 Gateway CA 链材料。 */
     discardGatewayCaChain(gatewayUrl, chainAid = '') {
-        const cacheKey = chainAid ? `${gatewayUrl}:${chainAid}` : gatewayUrl;
-        this._gatewayChainCache.delete(cacheKey);
-        this._gatewayCaVerified.delete(cacheKey);
+        this.invalidateStrictPkiCache();
     }
     // ── 内部方法：短连接 RPC ────────────────────────────────────
     /**
@@ -1541,22 +1600,27 @@ export class AuthFlow {
      * 4. BasicConstraints 检查
      * 5. 根证书自签 + 受信根锚定
      */
-    async _verifyAuthCertChain(gatewayUrl, authCert, chainAid = '', signedAt, fresh = false, suppliedChain) {
-        const certSerial = _certSerialHex(authCert) + (signedAt === undefined ? '' : `:signed:${signedAt}`);
-        // 检查缓存
-        const cachedAt = this._chainVerifiedCache.get(certSerial);
-        if (!fresh && cachedAt && Date.now() - cachedAt < this._chainCacheTtl) {
-            return;
-        }
+    async _verifyAuthCertChain(gatewayUrl, authCert, chainAid = '', signedAt, _fresh = false, suppliedChain) {
+        const epoch = this._strictPkiEpoch;
         const nowMs = signedAt === undefined ? Date.now() : signedAt * 1000;
         _ensureCertTimeValid(authCert, 'auth certificate', nowMs);
         const chain = suppliedChain ?? await this._loadGatewayCaChain(gatewayUrl, chainAid);
         if (!chain.length) {
             throw new AuthError('unable to verify auth certificate chain: missing CA chain');
         }
-        const cacheKey = (chainAid ? `${gatewayUrl}:${chainAid}` : gatewayUrl) + (signedAt === undefined ? '' : `:signed:${signedAt}`);
+        const trustedRoots = this._loadTrustedRoots();
+        const cacheKey = JSON.stringify([gatewayUrl, chain.map((cert) => cert.fingerprint256), trustedRoots.map((cert) => cert.fingerprint256), signedAt === undefined ? 'current' : 'historical']);
+        const certKey = JSON.stringify([cacheKey, chainAid, authCert.fingerprint256]);
+        const now = Date.now();
+        const expiresAt = Math.min(now + this._chainCacheTtl, Date.parse(authCert.validTo), ...chain.map((cert) => Date.parse(cert.validTo)));
+        const chainExpiresAt = Math.min(now + this._chainCacheTtl, ...chain.map((cert) => Date.parse(cert.validTo)));
+        for (const caCert of chain)
+            _ensureCertTimeValid(caCert, 'CA certificate', nowMs);
+        // 检查缓存
+        if ((this._chainVerifiedCache.get(certKey) ?? 0) > now)
+            return;
         // 快速路径：CA 链已通过完整验证
-        if (!fresh && this._gatewayCaVerified.get(cacheKey)) {
+        if ((this._gatewayCaVerified.get(cacheKey) ?? 0) > now) {
             const issuer = chain[0];
             _ensureCertTimeValid(issuer, 'Issuer CA', nowMs);
             if (!_isCaCert(issuer)) {
@@ -1568,7 +1632,8 @@ export class AuthFlow {
             if (!_verifyCertSignedBy(authCert, issuer)) {
                 throw new AuthError('auth certificate signature verification failed');
             }
-            this._chainVerifiedCache.set(certSerial, Date.now());
+            if (epoch === this._strictPkiEpoch)
+                this._chainVerifiedCache.set(certKey, Math.min(expiresAt, this._gatewayCaVerified.get(cacheKey)));
             return;
         }
         // 首次验证：完整验证流程
@@ -1596,25 +1661,60 @@ export class AuthFlow {
             throw new AuthError('auth certificate chain root self-signature verification failed');
         }
         // 验证根证书在受信列表中
-        const trustedRoots = this._loadTrustedRoots();
         const rootDer = _certDer(root);
         const isTrusted = trustedRoots.some((tr) => _certDer(tr).equals(rootDer));
         if (!isTrusted) {
             throw new AuthError('auth certificate chain is not anchored by a trusted root');
         }
         // 验证成功，更新缓存
-        this._chainVerifiedCache.set(certSerial, Date.now());
-        this._gatewayCaVerified.set(cacheKey, true);
+        if (epoch === this._strictPkiEpoch) {
+            this._chainVerifiedCache.set(certKey, expiresAt);
+            this._gatewayCaVerified.set(cacheKey, chainExpiresAt);
+        }
     }
     /** 加载 Gateway CA 链（带缓存） */
-    async _loadGatewayCaChain(gatewayUrl, chainAid = '') {
-        const cacheKey = chainAid ? `${gatewayUrl}:${chainAid}` : gatewayUrl;
-        let cached = this._gatewayChainCache.get(cacheKey);
-        if (!cached) {
-            cached = await this._fetchGatewayCaChain(gatewayUrl, chainAid);
-            this._gatewayChainCache.set(cacheKey, cached);
+    async _loadGatewayCaChain(gatewayUrl, chainAid = '', ownership = false, fresh = false) {
+        const cacheKey = (ownership ? 'ownership:' : '') + (chainAid ? `${gatewayUrl}:${chainAid}` : gatewayUrl);
+        const cached = this._gatewayChainCache.get(cacheKey);
+        if (cached && cached.expiresAt > Date.now())
+            return cached.chain.map(_loadX509);
+        const pending = this._gatewayChainLoads.get(cacheKey);
+        if (pending)
+            return pending;
+        const epoch = this._strictPkiEpoch;
+        const load = (async () => {
+            let pems;
+            if (ownership) {
+                const response = await this._fetchOwnershipPki(_gatewayHttpUrl(gatewayUrl, `/pki/chain/${encodeURIComponent(chainAid)}`));
+                if (response.status !== 200 || !response.body.trim())
+                    throw new StateError('ownership certificate chain is unavailable', { stringCode: 'unavailable', retryable: true });
+                pems = _splitPemBundle(response.body);
+                if (!pems.length)
+                    throw new ValidationError('ownership certificate chain PEM is invalid', { stringCode: 'invalid' });
+            }
+            else
+                pems = await this._fetchGatewayCaChain(gatewayUrl, chainAid, fresh);
+            let chain;
+            try {
+                chain = pems.map(_loadX509);
+            }
+            catch (error) {
+                if (ownership)
+                    throw new ValidationError('ownership certificate chain PEM is invalid', { stringCode: 'invalid' });
+                throw error;
+            }
+            if (epoch === this._strictPkiEpoch && chain.length)
+                this._gatewayChainCache.set(cacheKey, { chain: pems, expiresAt: Math.min(Date.now() + 3600_000, ...chain.map((cert) => Date.parse(cert.validTo))) });
+            return chain;
+        })();
+        this._gatewayChainLoads.set(cacheKey, load);
+        try {
+            return await load;
+        }
+        finally {
+            if (this._gatewayChainLoads.get(cacheKey) === load)
+                this._gatewayChainLoads.delete(cacheKey);
         }
-        return cached.map((pem) => _loadX509(pem));
     }
     /** 从 Gateway PKI 端点获取 CA 链 */
     async _fetchFreshPkiJson(url) {
@@ -1667,8 +1767,10 @@ export class AuthFlow {
         if (cached && cached.nextRefreshAt > now) {
             return cached.revokedSerials;
         }
+        const epoch = this._strictPkiEpoch;
         const entry = await this._fetchGatewayCrl(gatewayUrl, issuerCert);
-        this._gatewayCrlCache.set(gatewayUrl, entry);
+        if (epoch === this._strictPkiEpoch)
+            this._gatewayCrlCache.set(gatewayUrl, entry);
         return entry.revokedSerials;
     }
     /**
@@ -1690,14 +1792,15 @@ export class AuthFlow {
             throw new AuthError('gateway CRL endpoint returned no signed CRL');
         }
         if (fresh)
-            return { revokedSerials: _strictCrlRevokedSerials(crlPem, _issuerCert, Date.now() / 1000), nextRefreshAt: Date.now() };
+            return _strictCrlRevokedSerials(crlPem, _issuerCert, Date.now() / 1000);
         // 从 JSON 响应中提取吊销序列号列表
         // Gateway 的 crl.json 同时包含 crl_pem（签名 CRL）和 revoked_serials（方便客户端解析）
         let revokedSerials = new Set();
+        const bounds = { nextRefreshAt: Date.now() + 300_000 };
         // 尝试解析 CRL PEM 以提取吊销序列号
         // Node.js 不直接支持 CRL 解析，尝试从 DER 中手动提取
         try {
-            revokedSerials = this._parseCrlRevokedSerials(crlPem, _issuerCert);
+            revokedSerials = this._parseCrlRevokedSerials(crlPem, _issuerCert, bounds);
         }
         catch {
             // CRL 解析失败时，降级使用 JSON 响应中的 revoked_serials（如果提供）
@@ -1712,7 +1815,7 @@ export class AuthFlow {
         const now = Date.now();
         let nextRefreshAt = now + 300_000; // 5 分钟
         const maxRefreshAt = now + 86400_000; // 24 小时
-        nextRefreshAt = Math.min(nextRefreshAt, maxRefreshAt);
+        nextRefreshAt = Math.min(nextRefreshAt, maxRefreshAt, bounds.nextRefreshAt);
         return { revokedSerials, nextRefreshAt };
     }
     /**
@@ -1736,7 +1839,7 @@ export class AuthFlow {
      *   ...
      * }
      */
-    _parseCrlRevokedSerials(crlPem, issuerCert) {
+    _parseCrlRevokedSerials(crlPem, issuerCert, bounds) {
         // 提取 DER 数据
         const b64 = crlPem
             .replace(/-----BEGIN X509 CRL-----/g, '')
@@ -1774,6 +1877,17 @@ export class AuthFlow {
                 throw new AuthError('gateway CRL signature verification failed');
             }
         }
+        if (bounds) {
+            const fields = _ownershipDerChildren(_ownershipDer(der.subarray(tbsStart, tbsStart + tbs.totalLength)), 0x30);
+            const version = fields[0]?.tag === 2 ? 1 : 0;
+            let nextUpdate = fields[version + 3];
+            if (nextUpdate?.tag === 23) {
+                const text = nextUpdate.content.toString('ascii');
+                nextUpdate = { ...nextUpdate, tag: 24, content: Buffer.from(`${Number(text.slice(0, 2)) >= 50 ? '19' : '20'}${text}`) };
+            }
+            if (nextUpdate && nextUpdate.tag === 24)
+                bounds.nextRefreshAt = _ownershipOcspTime(nextUpdate) * 1000;
+        }
         // 解析 TBSCertList 内部字段以找到 revokedCertificates
         const revokedSerials = new Set();
         let offset = tbs.contentOffset;
@@ -1870,20 +1984,21 @@ export class AuthFlow {
             if (typeof payload.ocsp_response !== 'string' || !isStrictBase64(ocspB64))
                 throw new AuthError('service event signed current OCSP is unavailable or invalid');
             const verified = _verifyOwnershipOcsp(Buffer.from(ocspB64, 'base64'), authCert, issuerCert, Date.now() / 1000);
-            if (payload.status !== undefined && payload.status !== verified)
+            if (payload.status !== undefined && payload.status !== verified.status)
                 throw new AuthError('service event OCSP status mismatch');
-            if (verified !== 'good')
-                throw new AuthError(`service event certificate OCSP status is ${verified}`);
-            return { status: verified, nextRefreshAt: Date.now() };
+            if (verified.status !== 'good')
+                throw new AuthError(`service event certificate OCSP status is ${verified.status}`);
+            return verified;
         }
         if (!ocspB64) {
             throw new AuthError('gateway OCSP endpoint returned no ocsp_response');
         }
         let effectiveStatus;
+        const bounds = { nextRefreshAt: Date.now() + 300_000 };
         try {
             // 尝试解析 DER OCSP 响应
             const ocspDer = Buffer.from(ocspB64, 'base64');
-            effectiveStatus = this._parseOcspResponse(ocspDer, authCert, issuerCert);
+            effectiveStatus = this._parseOcspResponse(ocspDer, authCert, issuerCert, bounds);
         }
         catch (e) {
             // OCSP DER 解析失败时，降级信赖 JSON status 字段
@@ -1901,7 +2016,7 @@ export class AuthFlow {
         }
         // 缓存 TTL：默认 5 分钟，最大 24 小时
         const now = Date.now();
-        const nextRefreshAt = Math.min(now + 300_000, now + 86400_000);
+        const nextRefreshAt = Math.min(now + 300_000, now + 86400_000, bounds.nextRefreshAt);
         return { status: effectiveStatus, nextRefreshAt };
     }
     /**
@@ -1940,7 +2055,7 @@ export class AuthFlow {
      * 这里只做关键字段提取：responseStatus、certStatus。
      * 完整签名验证依赖更全面的 ASN.1 库。
      */
-    _parseOcspResponse(ocspDer, _authCert, _issuerCert) {
+    _parseOcspResponse(ocspDer, _authCert, _issuerCert, bounds) {
         // 外层 SEQUENCE
         const outer = this._readAsn1Sequence(ocspDer, 0);
         if (!outer)
@@ -2039,6 +2154,15 @@ export class AuthFlow {
         const certStatusByte = basicDer[srOffset];
         // context-specific tag class (bits 7-6 = 10), constructed bit (bit 5)
         const tagNumber = certStatusByte & 0x1f;
+        if (bounds) {
+            const status = this._readAsn1Tag(basicDer, srOffset);
+            const thisUpdate = status && this._readAsn1Tag(basicDer, srOffset + status.totalLength);
+            const nextOffset = status && thisUpdate ? srOffset + status.totalLength + thisUpdate.totalLength : singleSeq.contentOffset + singleSeq.contentLength;
+            if (nextOffset < singleSeq.contentOffset + singleSeq.contentLength && basicDer[nextOffset] === 0xa0) {
+                const nextUpdate = _ownershipDerChildren(_ownershipDer(basicDer.subarray(nextOffset)))[0];
+                bounds.nextRefreshAt = _ownershipOcspTime(nextUpdate) * 1000;
+            }
+        }
         if (tagNumber === 0)
             return 'good';
         if (tagNumber === 1)
@@ -2477,6 +2601,7 @@ export class AuthFlow {
     // ── 内部方法：根证书管理 ───────────────────────────────────
     /** 重新从磁盘加载信任根证书，供 meta.import_trust_roots 后刷新使用。 */
     reloadTrustedRoots() {
+        this.invalidateStrictPkiCache();
         this._rootCerts = this._loadRootCerts(this._rootCaPath);
         this._gatewayCaVerified.clear();
         this._chainVerifiedCache.clear();
@@ -2558,9 +2683,28 @@ export class AuthFlow {
         }
         return certs;
     }
+    invalidateStrictPkiCache() {
+        this._strictPkiEpoch++;
+        this._strictPkiCache.clear();
+        this._peerPkiCache.clear();
+        this._chainVerifiedCache.clear();
+        this._gatewayCaVerified.clear();
+        this._gatewayChainCache.clear();
+        this._gatewayChainLoads.clear();
+        this._gatewayCrlCache.clear();
+        this._gatewayOcspCache.clear();
+    }
     /** 清理过期的 gateway 缓存条目（供外部定时调用） */
     cleanExpiredCaches() {
         const now = Date.now();
+        for (const [k, v] of this._strictPkiCache) {
+            if (v.epoch !== this._strictPkiEpoch || v.expiresAt <= now)
+                this._strictPkiCache.delete(k);
+        }
+        for (const [k, v] of this._peerPkiCache) {
+            if (v.epoch !== this._strictPkiEpoch || v.expiresAt <= now)
+                this._peerPkiCache.delete(k);
+        }
         for (const [k, v] of this._gatewayCrlCache) {
             if (v.nextRefreshAt <= now)
                 this._gatewayCrlCache.delete(k);
@@ -2574,9 +2718,17 @@ export class AuthFlow {
                 this._gatewayOcspCache.delete(k);
         }
         for (const [k, v] of this._chainVerifiedCache) {
-            if (now - v >= 300_000)
+            if (v <= now)
                 this._chainVerifiedCache.delete(k);
         }
+        for (const [k, v] of this._gatewayCaVerified) {
+            if (v <= now)
+                this._gatewayCaVerified.delete(k);
+        }
+        for (const [k, v] of this._gatewayChainCache) {
+            if (v.expiresAt <= now)
+                this._gatewayChainCache.delete(k);
+        }
     }
 }
 //# sourceMappingURL=auth.js.map