@xcanwin/manyoyo 8.5.1 → 8.6.0

package/bin/manyoyo.js

@@ -49,7 +49,7 @@ const { applyAptMirror } = require('../lib/mirrors');
 const containerState = require('../lib/container-state');
 const { buildExecArgs, resolveContainerId } = require('../lib/container-exec');
 const { createNetworkManager, NETWORK_NAME } = require('../lib/container-network');
-const { normalizePolicy } = require('../lib/network-policy');
+const { normalizePolicy, isUnrestricted: isUnrestrictedPolicy } = require('../lib/network-policy');
 const { withEnvEndpoints } = require('../lib/network-endpoints');
 const { resolveManageOptions } = require('../lib/container-manage-options');
 const {
@@ -354,7 +354,7 @@ function installServeProcessDiagnostics(logger) {
  * @property {string} [containerRuntime] - 容器运行时（auto/docker/podman，默认 auto；仅全局配置生效）
  * @property {string} [autostart] - 容器每次启动时由容器内 init 执行的 bash 脚本（新建容器时写入状态目录）
  * @property {boolean} [autostartOnServe] - serve 启动时自动拉起此容器
- * @property {object} [network] - 网络策略（preset / host / egress / peers，见 lib/network-policy.js），不写为默认收紧
+ * @property {object} [network] - 网络策略（preset / outbound / inbound / expose，见 lib/network-policy.js），不写为默认收紧
  * @property {{apt?: string, npm?: string, pip?: string}} [mirrors] - 容器内 apt/npm/pip 软件源（http/https URL，空/缺省为官方默认；仅全局配置生效）
  * @property {boolean} [updateCheck] - serve 是否每天检查一次新版本（默认 true；仅全局配置生效，请求不附带任何本机信息）
  * @property {number} [cacheTTL] - 缓存过期天数
@@ -2141,8 +2141,8 @@ async function createNewContainer(runtime) {
 
     await ensureRunImage(runtime);
 
-    const networkPolicy = await withEnvEndpoints(normalizePolicy(runtime.network), [...userEnvLines, ...containerState.readEnvFilePaths(runtime.envFiles || []).flatMap(file => file.entries.map(entry => `${entry.key}=${entry.value}`))]);
     const networkManager = createCliNetworkManager(runtime);
+    const networkPolicy = await withEnvEndpoints(await networkManager.resolveRefs(normalizePolicy(runtime.network)), [...userEnvLines, ...containerState.readEnvFilePaths(runtime.envFiles || []).flatMap(file => file.entries.map(entry => `${entry.key}=${entry.value}`))]);
     if (!hasNetworkArg([...(runtime.contModeArgs || []), ...(runtime.containerExtraArgs || [])])) {
         try {
             await networkManager.ensureBridgeNetwork();
@@ -2156,7 +2156,7 @@ async function createNewContainer(runtime) {
         envFiles: runtime.envFiles,
         autostart: runtime.autostart,
         network: networkPolicy,
-        netRequired: networkPolicy.preset !== 'open',
+        netRequired: !isUnrestrictedPolicy(networkPolicy),
         meta: { name: runtime.containerName }
     });
 

package/lib/container-network.js

@@ -98,6 +98,11 @@ function parseUrlHostPort(value) {
     }
 }
 
+// 指向宿主机的代理（host.*.internal / loopback）要放行到容器里看到的宿主机 IP，而不是在宿主机上解析
+function isHostTarget(host) {
+    return HOST_NAMES.includes(host) || host === 'localhost' || host === '::1' || /^127\./.test(host);
+}
+
 function uniqueBy(items, keyFn) {
     const seen = new Set();
     return items.filter(item => {
@@ -148,7 +153,7 @@ function createNetworkManager(options) {
         });
     }
 
-    // 域名白名单的过滤代理：manyoyo 网络里的 sidecar 容器，按来源 IP 认容器（见 egress-sidecar.js）
+    // 域名规则的过滤代理：manyoyo 网络里的 sidecar 容器，按来源 IP 认容器（见 egress-sidecar.js）
     const sidecar = createSidecarManager({ run, command, homeDir, imageRef: getImageRef, networkName: NETWORK_NAME, ensureNetwork: ensureBridgeNetwork, getUpstream });
 
     // buildExecArgs 只需要同步 inspect 取 id；这里 withEnv:false 不会用到
@@ -180,6 +185,13 @@ function createNetworkManager(options) {
         })).filter(item => state.isValidId(item.id));
     }
 
+    // 把策略里按名称写的 @container:<名称> 换成 id；名称找不到抛错
+    async function resolveRefs(policy) {
+        if (!policyLib.hasNameRefs(policy)) return policy;
+        const byName = new Map((await listManaged()).map(item => [item.name, item.id]));
+        return policyLib.resolveContainerRefs(policy, name => byName.get(name) || '');
+    }
+
     function loadPolicy(id) {
         const raw = state.readNetworkRaw(homeDir, id);
         return policyLib.normalizePolicy(raw || undefined);
@@ -228,6 +240,29 @@ function createNetworkManager(options) {
         return await run(args, { timeout: 30000 });
     }
 
+    // 容器间：别的容器入站规则里允许了本容器（来源写 @containers 或 @container:<本容器>），本容器才能出去到它（派生行）。
+    // 来源写 @any 不派生：别的容器开放自己，不能顺带放宽本容器的出站限制
+    function computeDerived(self, all) {
+        const derived = [];
+        for (const other of all) {
+            if (other.id === self.id || !other.running || !state.stateExists(homeDir, other.id)) continue;
+            let otherPolicy;
+            try { otherPolicy = loadPolicy(other.id); } catch (e) { continue; }
+            const b = safeBridge(other.info);
+            if (!b) continue;
+            otherPolicy.inbound.filter(rule => rule.enabled && rule.action === 'allow' && (rule.source === '@containers' || rule.source === `@container:${self.id}`)).forEach(rule => {
+                derived.push({ id: other.id, name: other.name, ip: b.ip, ports: rule.ports, proto: rule.proto });
+            });
+        }
+        return derived;
+    }
+
+    async function derivedOf(name) {
+        const all = await listManaged();
+        const self = all.find(item => item.name === name);
+        return self ? computeDerived(self, all) : [];
+    }
+
     // 下发时现算：容器看到的宿主机 IP / DNS / 代理 / 镜像源 / peer 的当前 IP
     async function resolveEndpoints(self, policy, all) {
         const hostsText = await readRuntimeNetworkFacts(self.info);
@@ -239,10 +274,10 @@ function createNetworkManager(options) {
         const allow = [];
         const addHost = (ports, proto) => hostIps.forEach(ip => allow.push({ ip, ports: String(ports), proto }));
 
-        // 必需端点：上游代理、过滤代理、Playwright、镜像源
+        // 必需端点（@manyoyo）：上游代理、过滤代理、Playwright、镜像源
         const env = envMapOf(self.info);
         const proxyTargets = [];
-        // allowlist 下容器只能经过滤代理出网，上游代理不能直连放行（否则绕过域名白名单）
+        // allowlist 下容器只能经过滤代理出网，上游代理不能直连放行（否则绕过域名规则）
         if (policy.preset !== 'allowlist') {
             Object.keys(env).filter(key => PROXY_ENV_KEYS.has(key)).forEach(key => {
                 const parsed = env[key] && parseUrlHostPort(env[key]);
@@ -254,15 +289,20 @@ function createNetworkManager(options) {
             if (parsed) proxyTargets.push(parsed);
         });
         for (const target of uniqueBy(proxyTargets, t => `${t.host}:${t.port}`)) {
+            if (isHostTarget(target.host)) {
+                addHost(target.port, 'tcp');
+                continue;
+            }
             for (const ip of await resolveHostToIps(target.host)) allow.push({ ip, ports: String(target.port), proto: 'tcp' });
         }
-        // 过滤代理（sidecar 容器）：allowlist 容器经它出网，只放行到它的 IP:端口；
+        // 过滤代理（sidecar 容器）：有启用的域名规则时，容器的 HTTP(S) 经它出网，只放行到它的 IP:端口；
         // 容器发往它的包来源必须是自己的 IP（第二道保险：识别身份靠的就是来源 IP）
         let managedEnv = [];
         const antiSpoof = [];
-        if (policy.preset === 'allowlist' && policy.egress.domains.length) {
+        const proxied = policyLib.usesProxy(policy);
+        if (proxied) {
             const selfBridge = safeBridge(self.info);
-            if (!selfBridge) throw new Error('域名白名单需要容器在 manyoyo 网络里，这个容器的网络不支持');
+            if (!selfBridge) throw new Error('域名规则需要容器在 manyoyo 网络里，这个容器的网络不支持');
             const proxy = await sidecar.ensure();
             allow.push({ ip: proxy.ip, ports: String(proxy.port), proto: 'tcp' });
             antiSpoof.push({ daddr: proxy.ip, saddr: selfBridge.ip });
@@ -270,50 +310,55 @@ function createNetworkManager(options) {
             managedEnv = ['HTTP_PROXY', 'HTTPS_PROXY', 'http_proxy', 'https_proxy'].map(key => `${key}=${url}`);
         }
         playwrightHostPorts().forEach(port => addHost(port, 'tcp'));
-        policy.host.forEach(entry => addHost(entry.ports, entry.proto));
-
-        // 容器间：我的 peers.inbound 里的容器能进来；别人的 inbound 列了我，我才能出去
-        const peerIn = [];
-        const byId = new Map(all.map(item => [item.id, item]));
-        policy.peers.inbound.forEach(entry => {
-            const peer = byId.get(entry.from);
-            const b = peer && peer.running ? safeBridge(peer.info) : null;
-            if (b) peerIn.push({ ip: b.ip, ports: entry.ports, proto: entry.proto });
+
+        const containers = {};
+        all.forEach(item => {
+            const b = item.running ? safeBridge(item.info) : null;
+            if (b) containers[item.id] = b.ip;
         });
-        for (const other of all) {
-            if (other.id === self.id || !other.running || !state.stateExists(homeDir, other.id)) continue;
-            let otherPolicy;
-            try { otherPolicy = loadPolicy(other.id); } catch (e) { continue; }
-            const b = safeBridge(other.info);
-            if (!b) continue;
-            otherPolicy.peers.inbound.filter(entry => entry.from === self.id).forEach(entry => {
-                allow.push({ ip: b.ip, ports: entry.ports, proto: entry.proto });
-            });
-        }
-        return {
+        const derived = computeDerived(self, all);
+        derived.forEach(item => allow.push({ ip: item.ip, ports: item.ports, proto: item.proto }));
+        const bridge = bridgeOf(self.info);
+        const endpoints = {
             managedEnv,
             antiSpoof,
             dns: dnsServers,
             allow: uniqueBy(allow, a => `${a.ip}|${a.ports}|${a.proto}`),
-            peerIn,
-            bridge: bridgeOf(self.info) ? { subnet: bridgeOf(self.info).subnet, gateway: bridgeOf(self.info).gateway } : null
+            derived: uniqueBy(derived, d => `${d.id}|${d.ports}|${d.proto}`),
+            hostIps,
+            containers,
+            bridge: bridge ? { subnet: bridge.subnet, gateway: bridge.gateway } : null
         };
+        endpoints.proxyPolicy = proxied ? policyLib.compileProxyPolicy(policy, endpoints) : null;
+        return endpoints;
     }
 
     function safeBridge(info) {
         try { return bridgeOf(info); } catch (e) { return null; }
     }
 
-    // 过滤代理的「来源 IP → 容器 id + 策略」：所有运行中、属于本 HOME、策略是 allowlist 的容器
+    // 过滤代理的「来源 IP → 容器 id + 编译好的规则」：所有运行中、属于本 HOME、出站有域名规则的容器。
+    // 规则在容器自己下发时编译并缓存；缓存没有（serve 刚重启、CLI 新进程）就沿用 clients.json 里同 id 同 IP 的旧项
+    const clientCache = new Map();
+    function clientEntryOf(item, previous) {
+        const bridge = safeBridge(item.info);
+        if (!bridge) return null;
+        const cached = clientCache.get(item.id);
+        if (cached && cached.ip === bridge.ip) return { ip: bridge.ip, entry: cached.entry };
+        const old = previous[bridge.ip];
+        return old && old.id === item.id ? { ip: bridge.ip, entry: old } : null;
+    }
+
     function syncEgressClients(all) {
+        const previous = sidecar.readClients();
         const clients = {};
         for (const item of all) {
             if (!item.running || !state.stateExists(homeDir, item.id)) continue;
             let policy;
             try { policy = loadPolicy(item.id); } catch (e) { continue; }
-            if (policy.preset !== 'allowlist') continue;
-            const bridge = safeBridge(item.info);
-            if (bridge) clients[bridge.ip] = { id: item.id, preset: policy.preset, domains: policy.egress.domains, rules: policy.egress.rules };
+            if (!policyLib.usesProxy(policy)) continue;
+            const found = clientEntryOf(item, previous);
+            if (found) clients[found.ip] = found.entry;
         }
         sidecar.writeClients(clients);
     }
@@ -366,10 +411,13 @@ function createNetworkManager(options) {
                 state.writeNetStatus(homeDir, self.id, status);
                 return { ...status, id: self.id };
             }
-            state.setNetRequired(homeDir, self.id, policy.preset !== 'open');
+            state.setNetRequired(homeDir, self.id, !policyLib.isUnrestricted(policy));
             const endpoints = await resolveEndpoints(self, policy, all);
             state.syncFilesEnv(homeDir, self.id); // 环境变量文件的最新快照（供自启动脚本用）
             state.writeManagedEnv(homeDir, self.id, endpoints.managedEnv);
+            const selfBridge = safeBridge(self.info);
+            if (endpoints.proxyPolicy && selfBridge) clientCache.set(self.id, { ip: selfBridge.ip, entry: { id: self.id, ...endpoints.proxyPolicy } });
+            else clientCache.delete(self.id);
             syncEgressClients(all); // 先让代理认得这个容器，再放行门闩
             await sendRuleset(name, policyLib.buildNftRuleset(policy, endpoints));
             await execInContainer(name, ['/bin/sh', '-c', `mkdir -p ${path.posix.dirname(GATE_READY)} && : > ${GATE_READY}`]);
@@ -378,7 +426,7 @@ function createNetworkManager(options) {
                 status: 'applied',
                 startedAt,
                 policyHash: policyHashOf(policy),
-                warning: privileged && policy.preset !== 'open' ? '特权容器（dind / sock 模式）里的进程自带 NET_ADMIN，可以改动这些规则，网络限制没有约束力' : '',
+                warning: privileged && !policyLib.isUnrestricted(policy) ? '特权容器（dind / sock 模式）里的进程自带 NET_ADMIN，可以改动这些规则，网络限制没有约束力' : '',
                 at: new Date().toISOString()
             };
             state.writeNetStatus(homeDir, self.id, status);
@@ -386,7 +434,7 @@ function createNetworkManager(options) {
         } catch (e) {
             const message = `网络规则下发失败: ${e.message}`;
             try { state.writeNetStatus(homeDir, self.id, { status: 'error', message, startedAt, at: new Date().toISOString() }); } catch (err) { /* 状态目录可能已被删 */ }
-            // 旧规则可能还在（比如 open → allowlist 失败）：清掉门闩，让 manyoyo 的 exec 与自启动都按“未下发”处理
+            // 旧规则可能还在（比如不限制 → 收紧失败）：清掉门闩，让 manyoyo 的 exec 与自启动都按“未下发”处理
             await clearGate(name);
             const error = new Error(message);
             error.cause = e;
@@ -420,7 +468,7 @@ function createNetworkManager(options) {
         } catch (e) {
             policy = null; // 策略文件损坏：按收紧处理，下发时会报错
         }
-        if (policy && policy.preset === 'open') return { status: 'open' };
+        if (policy && policyLib.isUnrestricted(policy)) return { status: 'unrestricted' };
         // 判断依据在宿主机侧（net-status.json：同一次启动 + 同一份策略 + 下发成功），不依赖容器里的任何文件或命令
         const status = state.readNetStatus(homeDir, id);
         const startedAt = String((info.State && info.State.StartedAt) || '');
@@ -428,20 +476,25 @@ function createNetworkManager(options) {
         if (sameRun && status.status === 'unsupported') return { status: 'unsupported' };
         if (policy && sameRun && status.status === 'applied' && status.policyHash === policyHashOf(policy)) {
             // 规则还在，但过滤代理可能意外退了（容器出网此时是失败即关闭）：顺手拉起，失败不拦 exec
-            if (policy.preset === 'allowlist' && policy.egress.domains.length) {
+            if (policyLib.usesProxy(policy)) {
                 try {
                     if (!await sidecar.isHealthy()) {
                         await sidecar.ensure();
                         syncEgressClients(await listManaged());
                     }
-                } catch (e) { warn(`域名白名单代理恢复失败: ${e.message}`); }
+                } catch (e) { warn(`域名规则代理恢复失败: ${e.message}`); }
+                // 代理不认识这个容器（规则没缓存、clients.json 里也没有）：重新下发一次
+                if (!clientEntryOf({ id, info }, sidecar.readClients())) return await apply(name, { expectId: id });
             }
             return { status: 'applied' };
         }
         return await apply(name, { expectId: id });
     }
 
-    // 与 `name` 有 peers 关系的其他运行中容器（本容器重启后 IP 变化时要重算它们）
+    // 与 `name` 有容器间规则关系的其他运行中容器（本容器重启后 IP 变化时要重算它们）
+    const rulesOf = policy => [...policy.outbound, ...policy.inbound].filter(rule => rule.enabled);
+    const refersTo = (policy, id) => rulesOf(policy).some(rule => (rule.target || rule.source) === `@container:${id}`);
+    const opensToContainers = policy => policy.inbound.some(rule => rule.enabled && rule.action === 'allow' && rule.source === '@containers');
     async function relatedContainers(name) {
         const all = await listManaged();
         const self = all.find(item => item.name === name);
@@ -452,7 +505,7 @@ function createNetworkManager(options) {
             let p;
             let mine;
             try { p = loadPolicy(other.id); mine = loadPolicy(self.id); } catch (e) { continue; }
-            if (p.peers.inbound.some(e => e.from === self.id) || mine.peers.inbound.some(e => e.from === other.id)) related.push(other.name);
+            if (refersTo(p, self.id) || refersTo(mine, other.id) || opensToContainers(p) || opensToContainers(mine)) related.push(other.name);
         }
         return related;
     }
@@ -468,22 +521,20 @@ function createNetworkManager(options) {
             }
         }
         // 没有容器需要重新下发规则时，过滤代理也要在（运行时重启后它同样是停着的）
-        await healSidecar().catch(e => warn(`域名白名单代理恢复失败: ${e.message}`));
+        await healSidecar().catch(e => warn(`域名规则代理恢复失败: ${e.message}`));
     }
 
-    // 订阅容器 start 事件：容器被外部重启（podman restart、machine 重启后手动 start）后 netns 重建、规则丢失，
-    // 事件到来就重新下发，并重算与它有 peers 关系的容器（它的 IP 可能变了）。
-    async function needsSidecar(all) {
+        async function needsSidecar(all) {
         return all.some(item => {
             if (!state.stateExists(homeDir, item.id)) return false;
             try {
                 const policy = loadPolicy(item.id);
-                return policy.preset === 'allowlist' && policy.egress.domains.length > 0;
+                return policyLib.usesProxy(policy);
             } catch (e) { return false; }
         });
     }
 
-    // 过滤代理容器自己退出 / 被删：有 allowlist 容器就拉起来，并重写映射
+    // 过滤代理容器自己退出 / 被删：有用到它的容器就拉起来，并重写映射
     let lastHealAt = 0;
     let healTimer = null;
     async function healSidecar() {
@@ -494,7 +545,7 @@ function createNetworkManager(options) {
             if (!healTimer) {
                 healTimer = setTimeout(() => {
                     healTimer = null;
-                    healSidecar().catch(e => warn(`域名白名单代理恢复失败: ${e.message}`));
+                    healSidecar().catch(e => warn(`域名规则代理恢复失败: ${e.message}`));
                 }, wait + 50);
                 if (healTimer.unref) healTimer.unref();
             }
@@ -601,7 +652,7 @@ function createNetworkManager(options) {
         };
     }
 
-    return { NETWORK_NAME, sidecar, run, listManaged, loadPolicy, ensureBridgeNetwork, apply, ensureReady, relatedContainers, resolveEndpoints, reconcileAll, watchStarts };
+    return { NETWORK_NAME, sidecar, run, listManaged, loadPolicy, resolveRefs, derivedOf, ensureBridgeNetwork, apply, ensureReady, relatedContainers, resolveEndpoints, reconcileAll, watchStarts };
 }
 
 module.exports = {
@@ -611,5 +662,6 @@ module.exports = {
     bridgeOf,
     parseHostsAndResolv,
     parseUrlHostPort,
+    isHostTarget,
     createNetworkManager
 };

package/lib/container-run.js

@@ -27,7 +27,7 @@ function buildContainerRunArgs(options) {
         '--name', options.containerName,
         '--entrypoint', `${SYS_MOUNT}/init.sh`,
         // docker 默认带 NET_RAW（podman 默认不带）：有它的容器能发原始包 / 伪造 ARP，冒充别的容器的来源 IP，
-        // 域名白名单的过滤代理就是按来源 IP 认容器的，所以统一去掉
+        // 域名规则的过滤代理就是按来源 IP 认容器的，所以统一去掉
         '--cap-drop', 'NET_RAW',
         ...(options.contModeArgs || []),
         ...(options.containerExtraArgs || []),

package/lib/egress-proxy.js

@@ -3,27 +3,43 @@
 const dns = require('dns').promises;
 const http = require('http');
 const net = require('net');
-const { domainAllowed, PRIVATE_V4, PRIVATE_V6 } = require('./network-policy');
+const { domainMatches, PRIVATE_V4, PRIVATE_V6 } = require('./network-policy');
 
-// 域名白名单的强制执行点：运行在 manyoyo 网络里专用 sidecar 容器中的 HTTP(S) 过滤代理（见 egress-sidecar.js）。
-// 开启 allowlist 的容器防火墙只放行到这个代理，直连被挡；这里按连接的来源 IP 认出是哪个容器（getClient），
-// 认不出的来源一律 403；按域名放行 CONNECT / 普通 HTTP，
-// 并且解析出的 IP 属于私有 / 环回 / 链路本地段一律拒绝（防借代理打宿主机 loopback 与 DNS 重绑定），
-// 除非该容器的 egress.rules 显式放行该 IP:端口。
+// 域名规则的强制执行点：运行在 manyoyo 网络里专用 sidecar 容器中的 HTTP(S) 过滤代理（见 egress-sidecar.js）。
+// 有启用域名规则的容器，HTTP(S) 都走这个代理，防火墙只放行到它；这里按连接的来源 IP 认出是哪个容器（getClient），
+// 认不出的来源一律 403；然后按该容器编译好的有序规则（域名行 + 地址行 + 模式默认行）从上往下找第一条命中的。
+// 地址行按“任一解析结果”匹配；通配域名命中后，解析结果若落在 @host / @private / @metadata，仍要有一条允许该地址的规则。
+// 环回 / 未指定 / 组播地址永远拒绝（防借代理打 sidecar 自己）。
 // 被拒绝时统一回 403（带 Proxy-Status，不带任何能暴露代理身份的内容），并通过 onDenied 记录。
 const CONNECT_TIMEOUT_MS = 15000;
 const IDLE_TIMEOUT_MS = 10 * 60 * 1000;
 const MAX_TUNNELS_PER_CONTAINER = 256;
+const LOOKUP_TIMEOUT_MS = 5000;
 
-const blocked = new net.BlockList();
-[...PRIVATE_V4, '127.0.0.0/8', '224.0.0.0/4', '255.255.255.255/32'].forEach(cidr => {
-    const [addr, prefix] = cidr.split('/');
-    blocked.addSubnet(addr, Number(prefix), 'ipv4');
-});
-[...PRIVATE_V6, 'fe80::/10', 'ff00::/8', '::1/128', '::/128'].forEach(cidr => {
-    const [addr, prefix] = cidr.split('/');
-    blocked.addSubnet(addr, Number(prefix), 'ipv6');
-});
+function withTimeout(promise, ms) {
+    let timer;
+    return Promise.race([promise, new Promise((resolve, reject) => { timer = setTimeout(() => reject(new Error('timeout')), ms); })]).finally(() => clearTimeout(timer));
+}
+
+async function liveOnly(ips) {
+    return ips.filter(ip => !checkList(floor, ip));
+}
+
+function blockListOf(cidrs) {
+    const list = new net.BlockList();
+    (cidrs || []).forEach(cidr => {
+        const [addr, prefix] = String(cidr).split('/');
+        const family = net.isIP(addr);
+        if (!family) return;
+        const type = family === 4 ? 'ipv4' : 'ipv6';
+        if (prefix === undefined) list.addAddress(addr, type);
+        else list.addSubnet(addr, Number(prefix), type);
+    });
+    return list;
+}
+
+const blocked = blockListOf([...PRIVATE_V4, ...PRIVATE_V6, 'fe80::/10', 'ff00::/8', '::1/128', '::/128', '127.0.0.0/8', '255.255.255.255/32']);
+const floor = blockListOf(['127.0.0.0/8', '0.0.0.0/8', '224.0.0.0/4', '255.255.255.255/32', '::1/128', '::/128', 'ff00::/8']);
 
 // ::ffff:a.b.c.d 与 NAT64（64:ff9b::/96）里嵌的 IPv4 要按 IPv4 判断
 function embeddedV4(ip) {
@@ -39,29 +55,102 @@ function embeddedV4(ip) {
     return '';
 }
 
+function checkList(list, ip) {
+    const addr = embeddedV4(ip) || ip;
+    const family = net.isIP(addr);
+    return family ? list.check(addr, family === 4 ? 'ipv4' : 'ipv6') : null;
+}
+
 function isRestrictedAddress(ip) {
-    const v4 = embeddedV4(ip);
-    if (v4) return blocked.check(v4, 'ipv4');
-    const family = net.isIP(ip);
-    if (!family) return true;
-    return blocked.check(ip, family === 4 ? 'ipv4' : 'ipv6');
+    const hit = checkList(blocked, ip);
+    return hit === null ? true : hit;
 }
 
-function ruleCovers(rule, ip, port) {
-    if (rule.proto && rule.proto !== 'tcp') return false;
-    if (rule.ports) {
-        const ok = rule.ports.split(',').some(item => {
-            const [a, b] = item.split('-').map(Number);
-            return port >= a && port <= (b === undefined ? a : b);
-        });
-        if (!ok) return false;
+const setCache = new WeakMap();
+function compiledSet(set) {
+    let compiled = setCache.get(set);
+    if (!compiled) {
+        compiled = { inc: blockListOf(set.inc), exc: blockListOf(set.exc) };
+        setCache.set(set, compiled);
     }
-    const [addr, prefixText] = rule.cidr.split('/');
-    const family = net.isIP(addr);
-    if (!family || net.isIP(ip) !== family) return false;
-    const list = new net.BlockList();
-    list.addSubnet(addr, prefixText === undefined ? (family === 4 ? 32 : 128) : Number(prefixText), family === 4 ? 'ipv4' : 'ipv6');
-    return list.check(ip, family === 4 ? 'ipv4' : 'ipv6');
+    return compiled;
+}
+
+/** 地址集合 {any, inc, exc} 是否包含 ip。 */
+function setCovers(set, ip) {
+    if (!set) return false;
+    const compiled = compiledSet(set);
+    if (!set.any && !checkList(compiled.inc, ip)) return false;
+    return !checkList(compiled.exc, ip);
+}
+
+const listCache = new WeakMap();
+function listCovers(cidrs, ip) {
+    let list = listCache.get(cidrs);
+    if (!list) {
+        list = blockListOf(cidrs);
+        listCache.set(cidrs, list);
+    }
+    return Boolean(checkList(list, ip));
+}
+
+function portsCover(ports, port) {
+    if (!ports) return true;
+    return String(ports).split(',').some(item => {
+        const [a, b] = item.split('-').map(Number);
+        return port >= a && port <= (b === undefined ? a : b);
+    });
+}
+
+/**
+ * 按容器编译好的有序规则判断一次连接。解析是惰性的：只有规则需要看地址时才查 DNS（被域名规则直接拒绝 / 放行的不用等 DNS）。
+ * @param {{rules: object[], default: string, sensitive?: string[]}} policy
+ * @param {string} host 目标主机（域名或 IP 字面量）
+ * @param {number} port
+ * @param {string[]|(() => Promise<string[]>)} ipsOrResolve 目标的解析结果，或惰性解析函数（目标本身是 IP 时就是它自己；解析不出来为空）
+ * @returns {Promise<{ok: boolean, reason?: string, usable?: string[]|null}>} usable 为 null 表示判断时没看地址，由调用方按解析结果挑
+ */
+async function decide(policy, host, port, ipsOrResolve) {
+    const isIp = net.isIP(host) !== 0;
+    const deny = reason => ({ ok: false, reason });
+    let live = null;
+    const liveIps = async () => {
+        if (live === null) {
+            const ips = Array.isArray(ipsOrResolve) ? ipsOrResolve : (isIp ? [host] : await ipsOrResolve());
+            live = { all: ips, ok: ips.filter(ip => !checkList(floor, ip)) };
+        }
+        return live;
+    };
+    const applies = rule => rule.proto !== 'udp' && portsCover(rule.ports, port);
+    const addressAllowed = ip => {
+        for (const rule of policy.rules) {
+            if (rule.domain || !applies(rule) || !setCovers(rule.addr, ip)) continue;
+            return rule.action === 'allow';
+        }
+        return policy.default === 'allow';
+    };
+    for (const rule of policy.rules) {
+        if (!applies(rule)) continue;
+        if (rule.domain) {
+            if (isIp || !domainMatches(rule.domain, host)) continue;
+            if (rule.action === 'deny') return deny('domain');
+            if (rule.domain.startsWith('*.')) {
+                const { all, ok } = await liveIps();
+                if (all.length && !ok.length) return deny('address');
+                const sensitive = policy.sensitive || [];
+                const usable = ok.filter(ip => !listCovers(sensitive, ip) || addressAllowed(ip));
+                if (ok.length && !usable.length) return deny('address');
+                return { ok: true, usable };
+            }
+            return { ok: true, usable: null };
+        }
+        const { all, ok } = await liveIps();
+        if (all.length && !ok.length) return deny('address');
+        const hit = ok.filter(ip => setCovers(rule.addr, ip));
+        if (!hit.length) continue;
+        return rule.action === 'allow' ? { ok: true, usable: isIp ? ok : hit } : deny('address');
+    }
+    return policy.default === 'allow' ? { ok: true, usable: null } : deny('domain');
 }
 
 function parseTarget(text) {
@@ -74,14 +163,16 @@ function parseTarget(text) {
 
 /**
  * @param {object} options
- * @param {(ip: string) => {id: string, preset: string, domains: string[], rules: object[]}|null} options.getClient 按来源 IP 认容器（认不出返回 null）
+ * @param {(ip: string) => {id: string, default: string, sensitive?: string[], rules: object[]}|null} options.getClient 按来源 IP 认容器（认不出返回 null）
  * @param {(event: {id: string, host: string, port: number, reason: string}) => void} [options.onDenied] 拒绝记录
  * @param {string} [options.upstream] 上游 HTTP 代理 URL（串联）
  * @param {(host: string) => Promise<string[]>} [options.lookup] 测试替身
+ * @param {(ip: string) => string} [options.mapAddress] 测试替身：实际拨号的地址（单测里把虚构的公网 IP 映射到本机夹具）
  */
 function createEgressProxy(options) {
     const getClient = options.getClient;
     const onDenied = options.onDenied || (() => {});
+    const mapAddress = options.mapAddress || (ip => ip);
     const lookup = options.lookup || (async host => (await dns.lookup(host, { all: true })).map(r => r.address));
     // upstream 可以是字符串或返回字符串的函数（sidecar 里按文件改动热更新）；解析结果按字符串缓存
     let parsedFor = null;
@@ -120,33 +211,24 @@ function createEgressProxy(options) {
 
     // 返回 {ok:true, ip?} 或 {ok:false, status, message}
     async function authorize(policy, host, port, upstream) {
-        if (!policy || policy.preset !== 'allowlist') return { ok: false, status: 403, message: 'domain' };
+        if (!policy || !Array.isArray(policy.rules)) return { ok: false, status: 403, message: 'domain' };
         const isIp = net.isIP(host) !== 0;
-        const explicit = (ip, p) => (policy.rules || []).some(rule => ruleCovers(rule, ip, p));
-        if (isIp) {
-            if (isRestrictedAddress(host) && !explicit(host, port)) return { ok: false, status: 403, message: 'address' };
-            if (!explicit(host, port)) return { ok: false, status: 403, message: 'domain' };
-            return { ok: true, ip: host };
-        }
-        if (!domainAllowed(policy.domains, host)) return { ok: false, status: 403, message: 'domain' };
-        if (upstream) {
-            // 经上游代理时真正的连接由上游解析；这里仍做一次本地解析，解析得到私有 / 环回地址（且没有被显式放行）就拒绝。
-            // 本地解析不出来（宿主机不一定能解析）则放行给上游。残余风险：白名单里的通配域名若被控制了 DNS，
-            // 本地与上游可能得到不同答案——不要在白名单里放你不信任的通配域名。
-            try {
-                const local = await lookup(host);
-                if (local.length && local.every(ip => isRestrictedAddress(ip) && !explicit(ip, port))) return { ok: false, status: 403, message: 'address' };
-            } catch (e) { /* 本地解析失败：交给上游 */ }
-            return { ok: true, ip: '' };
-        }
-        let addresses;
-        try {
-            addresses = await lookup(host);
-        } catch (e) {
-            return { ok: false, status: 502, message: 'dns' };
-        }
-        const usable = addresses.filter(ip => !isRestrictedAddress(ip) || explicit(ip, port));
-        if (!usable.length) return { ok: false, status: 403, message: 'address' };
+        let addresses = null;
+        const resolveIps = async () => {
+            if (addresses === null) {
+                addresses = [];
+                try {
+                    addresses = await withTimeout(lookup(host), LOOKUP_TIMEOUT_MS);
+                } catch (e) { /* 解析不出来：规则里的域名行仍然判断；经上游代理时交给上游解析 */ }
+            }
+            return addresses;
+        };
+        const verdict = await decide(policy, host, port, isIp ? [host] : resolveIps);
+        if (!verdict.ok) return { ok: false, status: 403, message: verdict.reason };
+        if (upstream) return { ok: true, ip: '' };
+        // 直接拨号：需要地址。规则没看过地址时，从解析结果里挑非环回的
+        const usable = verdict.usable || (await liveOnly(isIp ? [host] : await resolveIps()));
+        if (!usable.length) return isIp || (addresses && addresses.length) ? { ok: false, status: 403, message: 'address' } : { ok: false, status: 502, message: 'dns' };
         return { ok: true, ip: usable[0] };
     }
 
@@ -234,7 +316,7 @@ function createEgressProxy(options) {
                 upstreamSocket.on('data', onData);
             });
         } else {
-            upstreamSocket = track(net.connect({ host: verdict.ip, port: target.port }));
+            upstreamSocket = track(net.connect({ host: mapAddress(verdict.ip), port: target.port }));
             upstreamSocket.setTimeout(CONNECT_TIMEOUT_MS, () => upstreamSocket.destroy());
             upstreamSocket.once('connect', () => {
                 upstreamSocket.setTimeout(IDLE_TIMEOUT_MS, () => upstreamSocket.destroy());
@@ -271,7 +353,7 @@ function createEgressProxy(options) {
         delete headers['proxy-connection'];
         const outbound = upstream
             ? { host: upstream.host, port: upstream.port, path: req.url, headers: { ...headers, ...(upstream.auth ? { 'proxy-authorization': upstream.auth } : {}) } }
-            : { host: verdict.ip, port, path: `${url.pathname}${url.search}`, headers };
+            : { host: mapAddress(verdict.ip), port, path: `${url.pathname}${url.search}`, headers };
         const proxyReq = http.request({ ...outbound, method: req.method, timeout: CONNECT_TIMEOUT_MS });
         let released = false;
         const done = () => { if (!released) { released = true; release(id); } };
@@ -312,4 +394,4 @@ function createEgressProxy(options) {
     return { start, stop, authorize, isListening: () => Boolean(server && server.listening) };
 }
 
-module.exports = { createEgressProxy, isRestrictedAddress, ruleCovers, parseTarget };
+module.exports = { createEgressProxy, isRestrictedAddress, decide, setCovers, parseTarget };