Youtube MITM 失败

[jayli]

代码版本：40395b0441f60faa9a64f2038d6d4ed00d1c73ae

MITM 证书问题调试小结

问题描述

启用 YouTube 广告拦截规则后，YouTube App 无法加载内容。关闭规则后正常工作。

已完成的排查

1. 证书链结构

• ✅ 已修复：叶子证书不再包含 rootCA（与旧版 anyproxy 一致）
• ✅ 验证：grep -c "BEGIN CERTIFICATE" 结果为 1

2. 证书类型

• ✅ 已修改：从 ECDSA P-256 改为 RSA-2048
• ✅ 验证：Public Key Algorithm: rsaEncryption, Public-Key: (2048 bit)

3. 证书扩展字段

• ✅ 已简化：只保留 Basic Constraints 和 SAN
• ✅ 验证：与旧版 anyproxy 证书结构完全一致

4. Subject 字段

• ✅ 已修复：继承 rootCA 的完整 Subject（C, O, ST, OU, CN）
• ✅ 验证：C=CN, O=AnyProxy, ST=SH, OU=AnyProxy SSL Proxy,
  CN=youtubei.googleapis.com

5. CA 证书链配置

• ✅ 已添加：createSecureContext 配置了 ca 参数
• ✅ 验证：ca: certMgr.getRootCAFilePath()

当前问题

TLS 握手失败

• 错误：socket hang up（客户端主动断开连接）
• 现象：secureConnection 事件从未触发
• 日志：连接建立后，客户端立即发送 socket hang up 错误

关键矛盾

• 新旧两个证书的结构完全相同
• 但旧版 anyproxy 可以正常工作
• 新版证书客户端拒绝连接

未排查的领域

1. TLS 握手细节
   - 加密套件选择
   - 证书链发送顺序
   - TLS 版本协商
2. 服务端配置差异
   - secureOptions 参数
   - ALPN 协议配置
   - 其他 TLS 相关选项
3. 网络层面
   - 抓包分析具体握手消息
   - 对比新旧版本的网络流量

建议下一步

1. 抓包对比：使用 Wireshark 或类似工具，对比新旧版本的 TLS 握手流程
2. 检查 secureOptions：对比新旧版本的 secureOptions 配置是否一致
3. 简化测试：创建一个最小化的 HTTPS 服务器，只返回证书，看是否能握手成功

代码变更位置

• /Users/hfy/jayli/block-proxy/proxy/proxy-core/cert-lifecycle.js - 证书生成逻辑
• /Users/hfy/jayli/block-proxy/proxy/proxy-core/https-server-mgr.js - HTTPS
  服务器配置
• /Users/hfy/jayli/block-proxy/proxy/proxy.js - rootCA 路径配置

[jayli]

我现在要继续排查 Youtube app MITM 不生效的问题，我现在将代码回滚到了
b08986f，这个节点是刚刚把 anyproxy
的外部依赖内置化掉了。我先验证这个改动是否ok。

经过实测，打开 youtube app 后，什么都加载不出来，我希望从这个节点开始找问题原因，
后面所有的改动都不要主动给我提交，必须等我的确认才能提交代码。

我再给一个信息，我手动在 8004 配置后台 把 YouTube 广告拦截 勾掉后，Youtube app 打
开后的列表信息是可以加载出来的，然后我把拦截主机列表里所有拦截选项都删掉后，Youtub
e app 的功能就一切正常了，但是没有了去广告的功能了。广告视频会正常播放。

但当我把主机列表里所有拦截选项都删掉，且将YouTube 广告拦截打上勾，Youtube app
就又不能加载首页的内容了。

我觉得大概率是之前去掉 AnyProxy 的这个包的依赖的改动带来的问题。即
#35 这次 PR 引入的问题，这次 PR
包括了三个关键改动：

e7ee8fb
4311520
8912dfd

我感觉大概率是这三次改动带来的问题

之前都是好用的，请你集中精力排查这三次提交。

另外还有一个思路，我现在已经将 config.json
里的拦截域名都删掉了，只留了Youtube广告拦截的规则打钩了，也就是说 rule.js
里的规则是生效的，我觉得为了排除干扰，可以将 rule.js 里 callback 原封不动的将原始
response
直接返回，排除因为请求返回内容的不同而造成的问题，集中精力搞定mitm的证书的问题。

这样的话，所有链路中影响功能的只有mitm的证书带来的。请你考虑这个思路。

我在去anyproxy之前的依赖的 anyproxy 的代码在 ../anyproxy/ 中

---

排查到一个高概率根因，并已做了不提交的本地修复：

cert/rootCA.crt 和运行时 ~/.anyproxy/certificates/rootCA.crt 不一致。后台 /
fetchCrtFile 发给手机的是 BlockProxy CA，但 proxy-core 实际用旧的 AnyProxy CA 动态签
发 YouTube 域名证书。这样只要开启 YouTube MITM，App 就会遇到证书链不匹配；关闭
YouTube 规则时不走 MITM，所以能正常加载。

我改了两处：

• proxy/proxy.js：ensureRootCA() 现在会比较 CA 指纹；如果 ~/.anyproxy 里的 rootCA 和
  项目 cert/rootCA.crt 不一致，就覆盖并清理旧域名证书缓存。

• test/proxy-core-connect-tests.js：新增 CA mismatch 回归测试，以及一个真实 CONNECT
  → HTTPS MITM → 原样 response 的链路测试。

我也已经同步了当前本机环境，结果是 replaced；现在 cert/rootCA.crt 和 ~/.anyproxy/
certificates/rootCA.crt 指纹一致，都是：

32:08:B2:4E:BA:18:7F:31:62:F5:8D:2A:47:08:0E:CF:16:9F:30:68:05:22:39:E6:A8:8D:E9:49:
3F:D9:3C:75

验证已跑：

• npm run test:proxy-core 通过
• npm run test:registry 通过
• npm run test:mitm-runtime 通过

没有提交代码。你现在需要重启代理服务后再测 YouTube App；rule.js 里保留你加的 return
null，这样仍然是在排除 response 改写干扰。

[jayli]

这批日志说明证书/MITM 握手已经通了：请求已经进入 HTTPS 解密后的 beforeSendRequest，
所以现在不是证书握手失败。

我定位到新的实际问题：rule.js 里 callback 虽然 return null，但
MITMHandler('beforeSendResponse') 在调用 callback 前会先执行
parseResponseFromZippedChunk(response)。这个函数原地修改了 response.header，会删除
Content-Encoding。结果是：callback 返回 null 后，body 仍可能是 gzip/br 压缩数据，但
响应头已经没了 Content-Encoding，YouTube App 会按未压缩 protobuf 解析，首页就加载失
败。

我已做最小修复：parseResponseFromZippedChunk() 现在复制 header 再处理，不污染原始
response。这样 callback 返回 null 时，响应才是真正原封不动返回。

新增并通过的测试：

• npm run test:mitm-runtime
• npm run test:proxy-core

仍然没有提交代码。你需要重启代理后再测一次 YouTube App；这次 rule.js 的 return null
才能真正排除 response 改写干扰。

---

做了两类改动，都是为了把 “开启 YouTube MITM 后 App 加载失败” 的变量拆开验证。

1. 修复 rootCA 同步问题

文件：proxy/proxy.js

原来的 ensureRootCA() 逻辑是：

只要 ~/.anyproxy/certificates/rootCA.crt 和 rootCA.key 存在，就直接跳过，不管它们是
不是当前项目 cert/rootCA.crt 对应的证书。

现场检查发现：

• 后台 /fetchCrtFile 提供给客户端安装的是 cert/rootCA.crt
• 运行时 proxy-core 动态签发域名证书用的是 ~/.anyproxy/certificates/rootCA.crt
• 当时这两个 CA 不一致：
  • cert/rootCA.crt 是 BlockProxy
  • ~/.anyproxy/certificates/rootCA.crt 是旧的 AnyProxy

这会导致：客户端信任的是 BlockProxy CA，但运行时签出来的是 AnyProxy CA。只要 YouTube
规则启用并触发 MITM，App 就可能证书校验失败。

我改成：

• 增加 getCertificateFingerprint(filePath)，用 crypto.X509Certificate 读取证书
  SHA256 指纹。

• ensureRootCA() 会比较项目 CA 和 ~/.anyproxy CA 的指纹。

• 如果不一致：

  • 覆盖 ~/.anyproxy/certificates/rootCA.crt
  • 覆盖 ~/.anyproxy/certificates/rootCA.key
  • 清理旧的动态域名证书缓存，避免继续使用旧 CA 签发过的域名证书

• 保留测试入口 _test.ensureRootCA 和 _test.getCertificateFingerprint

我也已经在当前机器上执行过同步，现在两个 CA 指纹一致。

2. 修复 return null 仍污染原始 response 的问题

文件：proxy/proxy.js

你在 rule.js 里把 YouTube callback 改成 return null，目的是排除 response 内容改写带
来的干扰。这个方向是对的。

但实际代码里还有一个隐藏问题：

MITMHandler('beforeSendResponse') 在调用 callback 之前，会先执行：

response = await parseResponseFromZippedChunk(response);

而 parseResponseFromZippedChunk() 原来是这样拿 header 的：

var resHeader = response.header;

这意味着它直接修改原始 response header。它会删除：

Content-Encoding
content-encoding

并添加：

x-anyproxy-origin-content-encoding
x-anyproxy-origin-content-length

所以即使 callback 最后 return null，原始 response 也已经被污染了。最危险的情况是：
body 还是 gzip/br 压缩数据，但 Content-Encoding 已被删掉，YouTube App 会按未压缩数据
解析，首页加载失败就很合理。

我改成：

var resHeader = { ...(response.header || {}) };

这样解压逻辑只修改 header 副本。callback 返回改写结果时才会使用这个副本；callback 返
回 null 时，原始 response header/body 保持不变。

3. 新增回归测试

文件：test/proxy-core-connect-tests.js

新增了两个测试：

• testEnsureRootCAReplacesMismatchedCache

  • 构造一个临时 .anyproxy/certificates
  • 放入不匹配的 rootCA
  • 放入旧域名证书缓存
  • 验证 ensureRootCA() 会替换 rootCA 并清理旧缓存

• testMitmConnectForwardsHttpsRequest

  • 建本地 HTTPS upstream
  • 建本地 proxy-core 代理
  • 通过 CONNECT 进入 MITM
  • 走 TLS 到本地 MITM server
  • 发起 HTTPS 请求
  • 验证响应能原样返回

这个测试证明基础 CONNECT → SNI → 动态证书 → HTTPS 转发链路是通的。

文件：test/mitm-runtime-tests.js

新增：

• testNullBeforeSendResponseDoesNotMutateOriginalResponse
  • 构造 gzip response
  • beforeSendResponse 规则 callback 返回 null
  • 验证原始 response 的 Content-Encoding: gzip 不会被删除
  • 验证 body 引用保持原样

这个测试先失败，确认了 bug；改完 header 浅拷贝后通过。

4. 已跑验证

已通过：

npm run test:proxy-core
npm run test:mitm-runtime
npm run test:registry

其中 test:mitm-runtime 覆盖了这次 response header 污染问题，test:proxy-core 覆盖了
CA 同步和基础 MITM 链路。

5. 没有提交代码

我没有执行 git commit。

当前工作树里还有你之前有意保留的现场调试改动：

• config.json
• proxy/mitm/rule.js 里的 return null
• proxy/proxy-core/request-handler.js 里的 [DEBUG-REQ] 日志

[jayli]

diff --git a/config.json b/config.json
index 4ac1ffa..1a73c77 100644
--- a/config.json
+++ b/config.json
@@ -1,75 +1,6 @@
 {
   "network_scanning_status": "0",
-  "block_hosts": [
-    {
-      "filter_host": "youtube.com",
-      "filter_match_rule": "^https?:\\/\\/(www|s)\\.youtube\\.com\\/(pagead|ptracking)",
-      "filter_start_time": "00:00",
-      "filter_end_time": "23:59",
-      "filter_weekday": [
-        1,
-        2,
-        3,
-        4,
-        5,
-        6,
-        7
-      ],
-      "filter_mac": "",
-      "compiledFilterRegexp": {}
-    },
-    {
-      "filter_host": "youtube.com",
-      "filter_match_rule": "^https?:\\/\\/s\\.youtube\\.com\\/api\\/stats\\/qoe\\?adcontext",
-      "filter_start_time": "00:00",
-      "filter_end_time": "23:59",
-      "filter_weekday": [
-        1,
-        2,
-        3,
-        4,
-        5,
-        6,
-        7
-      ],
-      "filter_mac": "",
-      "compiledFilterRegexp": {}
-    },
-    {
-      "filter_host": "youtube.com",
-      "filter_match_rule": "^https?:\\/\\/(www|s)\\.youtube\\.com\\/api\\/stats\\/ads",
-      "filter_start_time": "00:00",
-      "filter_end_time": "23:59",
-      "filter_weekday": [
-        1,
-        2,
-        3,
-        4,
-        5,
-        6,
-        7
-      ],
-      "filter_mac": "",
-      "compiledFilterRegexp": {}
-    },
-    {
-      "filter_host": "googlevideo.com",
-      "filter_match_rule": "^https?:\\/\\/[\\w-]+\\.googlevideo\\.com\\/(?!(dclk_video_ads|videoplayback\\?)).+&oad",
-      "filter_start_time": "00:00",
-      "filter_end_time": "23:59",
-      "filter_weekday": [
-        1,
-        2,
-        3,
-        4,
-        5,
-        6,
-        7
-      ],
-      "filter_mac": "",
-      "compiledFilterRegexp": {}
-    }
-  ],
+  "block_hosts": [],
   "proxy_port": 8001,
   "auth_username": "admin",
   "auth_password": "admin",
@@ -80,10 +11,87 @@
   "express_port": 8004,
   "enable_tunnel": "1",
   "tunnel_port": 8003,
-  "tunnel_domains": [
-  ],
-  "rule_modules": {},
+  "tunnel_domains": [],
+  "rule_modules": {
+    "builtin:Youtube": true
+  },
   "devices": [
+    {
+      "ip": "192.168.124.1",
+      "mac": "FA:27:3C:E5:31:5F"
+    },
+    {
+      "ip": "192.168.124.2",
+      "mac": "7C:DE:78:A9:83:A0"
+    },
+    {
+      "ip": "192.168.124.3",
+      "mac": "0:DD:B6:EA:E6:2A"
+    },
+    {
+      "ip": "192.168.124.6",
+      "mac": "0:DD:B6:EB:26:5C"
+    },
+    {
+      "ip": "192.168.124.10",
+      "mac": "FA:27:3C:E5:31:5F"
+    },
+    {
+      "ip": "192.168.124.11",
+      "mac": "FA:27:3C:E5:31:5F"
+    },
+    {
+      "ip": "192.168.124.34",
+      "mac": "D6:A0:61:69:67:F6"
+    },
+    {
+      "ip": "192.168.124.37",
+      "mac": "DE:1E:87:ED:17:8B"
+    },
+    {
+      "ip": "192.168.124.68",
+      "mac": "E2:4D:6E:1:21:6E"
+    },
+    {
+      "ip": "192.168.124.92",
+      "mac": "BA:85:EB:33:78:9B"
+    },
+    {
+      "ip": "192.168.124.99",
+      "mac": "72:A9:F0:34:E9:91"
+    },
+    {
+      "ip": "192.168.124.111",
+      "mac": "74:3F:C2:67:74:98"
+    },
+    {
+      "ip": "192.168.124.128",
+      "mac": "48:F3:F3:CA:1D:E"
+    },
+    {
+      "ip": "192.168.124.189",
+      "mac": "86:8E:78:A6:D9:3D"
+    },
+    {
+      "ip": "192.168.124.200",
+      "mac": "54:52:84:95:DF:5E"
+    },
+    {
+      "ip": "192.168.124.234",
+      "mac": "DC:97:58:D:FD:9F"
+    },
+    {
+      "ip": "192.168.124.240",
+      "mac": "F4:6B:8C:90:29:5"
+    },
+    {
+      "ip": "192.168.124.251",
+      "mac": "6E:FB:18:4D:9C:3E"
+    },
+    {
+      "ip": "192.168.124.125",
+      "mac": "14:C0:50:14:6E:A5"
+    }
   ],
   "enable_mitm": "1"
-}
+}
\ No newline at end of file
diff --git a/proxy/mitm/rule.js b/proxy/mitm/rule.js
index 942900e..6f9fde7 100644
--- a/proxy/mitm/rule.js
+++ b/proxy/mitm/rule.js
@@ -75,6 +75,7 @@ module.exports = {
         'host': 'youtubei.googleapis.com',
         'regexp': "/youtubei/v1/(browse|next|player|search|reel/reel_watch_sequence|guide|account/get_setting|get_watch)",
         'callback': async function(url, request, response) {
+          return null;
           return await hijackResponse(url, request, response, YoutubeResponse);
         } // -- callback
       },
@@ -84,6 +85,7 @@ module.exports = {
         host: "googlevideo.com",
         regexp: "(^https?://[\\w-]+\.googlevideo\.com/.+)(ctier=L)(&.+)",
         callback: async function(url, request, response) {
+          return null;
           const matchRegExp = new RegExp(this.regexp);
           const matchResult = url.match(matchRegExp);
           if (matchResult !== null) {
diff --git a/proxy/proxy-core/request-handler.js b/proxy/proxy-core/request-handler.js
index 8ab5308..28f42a3 100644
--- a/proxy/proxy-core/request-handler.js
+++ b/proxy/proxy-core/request-handler.js
@@ -362,6 +362,12 @@ function getUserReqHandler(userRule) {
     const host = req.headers.host;
     const protocol = (!!req.connection.encrypted && !(/^http:/).test(req.url)) ? 'https' : 'http';
 
+    console.log('[DEBUG-REQ] === Incoming Request ===');
+    console.log('[DEBUG-REQ] req.url:', req.url);
+    console.log('[DEBUG-REQ] req.headers.host (before reconstruct):', host);
+    console.log('[DEBUG-REQ] req.connection.encrypted:', !!req.connection.encrypted);
+    console.log('[DEBUG-REQ] protocol:', protocol);
+
     let fullUrl = protocol + '://' + host + req.url;
     if (protocol === 'http') {
       const reqUrlPattern = url.parse(req.url);
@@ -379,6 +385,8 @@ function getUserReqHandler(userRule) {
 
     // Reconstruct headers from rawHeaders
     req.headers = util.getHeaderFromRawHeaders(req.rawHeaders);
+    console.log('[DEBUG-REQ] req.headers.host (after reconstruct):', req.headers.host);
+    console.log('[DEBUG-REQ] req.headers keys:', Object.keys(req.headers));
 
     logUtil.printLog(`received request to: ${req.method} ${host}${path}`);
 
diff --git a/proxy/proxy.js b/proxy/proxy.js
index b941056..dda939c 100644
--- a/proxy/proxy.js
+++ b/proxy/proxy.js
@@ -14,6 +14,7 @@ const _util = require('../server/util.js');
 const os = require('os');
 const http = require("http");
 const https = require('https');
+const crypto = require('crypto');
 const { URL } = require('url');
 const axios = require('axios');
 const { HttpProxyAgent } = require('http-proxy-agent');
@@ -515,25 +516,57 @@ function getMacByIp(ipAddress) {
 // 保存代理服务器实例的变量
 let proxyServerInstance = null;
 
-function ensureRootCA() {
-  const anyproxyDir = path.join(os.homedir(), '.anyproxy', 'certificates');
-  const targetCrt = path.join(anyproxyDir, 'rootCA.crt');
-  const targetKey = path.join(anyproxyDir, 'rootCA.key');
-  const srcCrt = path.join(__dirname, '../cert/rootCA.crt');
-  const srcKey = path.join(__dirname, '../cert/rootCA.key');
+function getCertificateFingerprint(filePath) {
+  try {
+    const cert = new crypto.X509Certificate(fs.readFileSync(filePath));
+    return cert.fingerprint256;
+  } catch (e) {
+    return null;
+  }
+}
 
-  if (fs.existsSync(targetCrt) && fs.existsSync(targetKey)) {
+function clearGeneratedCertCache(anyproxyDir) {
+  if (!fs.existsSync(anyproxyDir)) {
     return;
   }
 
+  for (const fileName of fs.readdirSync(anyproxyDir)) {
+    if (fileName === 'rootCA.crt' || fileName === 'rootCA.key') {
+      continue;
+    }
+    const filePath = path.join(anyproxyDir, fileName);
+    if (fs.statSync(filePath).isFile()) {
+      fs.unlinkSync(filePath);
+    }
+  }
+}
+
+function ensureRootCA(options = {}) {
+  const anyproxyDir = options.anyproxyDir || path.join(os.homedir(), '.anyproxy', 'certificates');
+  const targetCrt = path.join(anyproxyDir, 'rootCA.crt');
+  const targetKey = path.join(anyproxyDir, 'rootCA.key');
+  const srcCrt = options.srcCrt || path.join(__dirname, '../cert/rootCA.crt');
+  const srcKey = options.srcKey || path.join(__dirname, '../cert/rootCA.key');
+
   if (!fs.existsSync(srcCrt) || !fs.existsSync(srcKey)) {
-    return;
+    return 'missing-source';
   }
 
   fs.mkdirSync(anyproxyDir, { recursive: true });
+  const hasTarget = fs.existsSync(targetCrt) && fs.existsSync(targetKey);
+  const srcFingerprint = getCertificateFingerprint(srcCrt);
+  const targetFingerprint = hasTarget ? getCertificateFingerprint(targetCrt) : null;
+  const shouldReplace = !hasTarget || !srcFingerprint || srcFingerprint !== targetFingerprint;
+
+  if (!shouldReplace) {
+    return 'unchanged';
+  }
+
+  clearGeneratedCertCache(anyproxyDir);
   fs.copyFileSync(srcCrt, targetCrt);
   fs.copyFileSync(srcKey, targetKey);
-  console.log('✅ 已将 cert/rootCA.* 复制到 ~/.anyproxy/certificates/');
+  console.log('✅ 已同步 cert/rootCA.* 到 ~/.anyproxy/certificates/，并清理旧域名证书缓存');
+  return hasTarget ? 'replaced' : 'created';
 }
 
 function startProxyServer() {
@@ -798,7 +831,7 @@ function getResponseRules() {
 // requestHandler.js 120 行 request() 里的逻辑
 function parseResponseFromZippedChunk(response) {
   return new Promise((resolve, reject) => {
-    var resHeader = response.header;
+    var resHeader = { ...(response.header || {}) };
     const contentEncoding = resHeader['content-encoding'] || resHeader['Content-Encoding'];
     const ifServerGzipped = /gzip/i.test(contentEncoding);
     const isServerDeflated = /deflate/i.test(contentEncoding);
@@ -1600,5 +1633,7 @@ module.exports._test = {
   },
   async runMITMHandler(type, url, request, response) {
     return MITMHandler(type, url, request, response);
-  }
+  },
+  ensureRootCA,
+  getCertificateFingerprint
 };
diff --git a/test/mitm-runtime-tests.js b/test/mitm-runtime-tests.js
index abec334..be6ab81 100644
--- a/test/mitm-runtime-tests.js
+++ b/test/mitm-runtime-tests.js
@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
 const assert = require('assert');
+const zlib = require('zlib');
 const mitmRegistry = require('../proxy/mitm/registry');
 const LocalProxy = require('../proxy/proxy');
 
@@ -93,6 +94,45 @@ function testYoutubeUaFilterRequiresEffectiveBuiltinYoutube() {
   LocalProxy._test.setEnableMitmForTest("1");
 }
 
+async function testNullBeforeSendResponseDoesNotMutateOriginalResponse() {
+  const registry = mitmRegistry.createRegistry({
+    builtinRules: {
+      Custom: [{
+        type: 'beforeSendResponse',
+        host: 'response.example.com',
+        regexp: '^https://response.example.com/path',
+        callback: async function() {
+          return null;
+        }
+      }]
+    },
+    config: {}
+  });
+  LocalProxy._test.setRuleRegistryForTest(registry);
+
+  const originalBody = zlib.gzipSync(Buffer.from('{"ok":true}'));
+  const response = {
+    statusCode: 200,
+    header: {
+      'Content-Encoding': 'gzip',
+      'Content-Length': String(originalBody.length)
+    },
+    body: originalBody
+  };
+
+  const result = await LocalProxy._test.runMITMHandler(
+    'beforeSendResponse',
+    'https://response.example.com/path',
+    {},
+    response
+  );
+
+  assert.strictEqual(result, null);
+  assert.strictEqual(response.header['Content-Encoding'], 'gzip');
+  assert.strictEqual(response.header['x-anyproxy-origin-content-encoding'], undefined);
+  assert.strictEqual(response.body, originalBody);
+}
+
 (async () => {
   await testDisabledRulesDoNotMitmOrBufferOrRewrite();
   console.log('PASS testDisabledRulesDoNotMitmOrBufferOrRewrite');
@@ -100,4 +140,6 @@ function testYoutubeUaFilterRequiresEffectiveBuiltinYoutube() {
   console.log('PASS testEnabledRulesRewriteAndPreserveThis');
   testYoutubeUaFilterRequiresEffectiveBuiltinYoutube();
   console.log('PASS testYoutubeUaFilterRequiresEffectiveBuiltinYoutube');
+  await testNullBeforeSendResponseDoesNotMutateOriginalResponse();
+  console.log('PASS testNullBeforeSendResponseDoesNotMutateOriginalResponse');
 })();
diff --git a/test/proxy-core-connect-tests.js b/test/proxy-core-connect-tests.js
index e7faef2..3a936b0 100644
--- a/test/proxy-core-connect-tests.js
+++ b/test/proxy-core-connect-tests.js
@@ -2,11 +2,17 @@
 
 const assert = require('assert');
 const constants = require('constants');
+const fs = require('fs');
 const http = require('http');
+const https = require('https');
+const path = require('path');
+const tls = require('tls');
 const { Duplex, PassThrough } = require('stream');
 const HttpsServerMgr = require('../proxy/proxy-core/https-server-mgr');
 const ProxyServer = require('../proxy/proxy-core/proxy-server');
 const RequestHandler = require('../proxy/proxy-core/request-handler');
+const util = require('../proxy/proxy-core/util');
+const LocalProxy = require('../proxy/proxy');
 
 class FakeClientSocket extends Duplex {
   constructor() {
@@ -150,6 +156,121 @@ function testProxyServerPassesTimeoutToRequestHandler() {
   assert.strictEqual(proxy.requestHandler.timeout, 4321);
 }
 
+function testEnsureRootCAReplacesMismatchedCache() {
+  const tmpDir = fs.mkdtempSync(path.join(require('os').tmpdir(), 'block-proxy-ca-'));
+  const certDir = path.join(tmpDir, 'certificates');
+  const srcDir = path.join(tmpDir, 'src');
+  fs.mkdirSync(certDir, { recursive: true });
+  fs.mkdirSync(srcDir, { recursive: true });
+
+  const srcCrt = path.join(srcDir, 'rootCA.crt');
+  const srcKey = path.join(srcDir, 'rootCA.key');
+  const targetCrt = path.join(certDir, 'rootCA.crt');
+  const targetKey = path.join(certDir, 'rootCA.key');
+  const staleDomainCrt = path.join(certDir, 'youtubei.googleapis.com.crt');
+  const staleDomainKey = path.join(certDir, 'youtubei.googleapis.com.key');
+
+  fs.copyFileSync(path.join(__dirname, '../cert/rootCA.crt'), srcCrt);
+  fs.copyFileSync(path.join(__dirname, '../cert/rootCA.key'), srcKey);
+  fs.writeFileSync(targetCrt, fs.readFileSync(path.join(__dirname, '../cert/tunnel_tls.crt')));
+  fs.writeFileSync(targetKey, fs.readFileSync(path.join(__dirname, '../cert/tunnel_tls.key')));
+  fs.writeFileSync(staleDomainCrt, 'stale cert');
+  fs.writeFileSync(staleDomainKey, 'stale key');
+
+  try {
+    const result = LocalProxy._test.ensureRootCA({
+      anyproxyDir: certDir,
+      srcCrt,
+      srcKey,
+    });
+
+    assert.strictEqual(result, 'replaced');
+    assert.strictEqual(fs.readFileSync(targetCrt, 'utf8'), fs.readFileSync(srcCrt, 'utf8'));
+    assert.strictEqual(fs.readFileSync(targetKey, 'utf8'), fs.readFileSync(srcKey, 'utf8'));
+    assert.strictEqual(fs.existsSync(staleDomainCrt), false);
+    assert.strictEqual(fs.existsSync(staleDomainKey), false);
+  } finally {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
+
+async function testMitmConnectForwardsHttpsRequest() {
+  const key = fs.readFileSync(path.join(__dirname, '../cert/rootCA.key'));
+  const cert = fs.readFileSync(path.join(__dirname, '../cert/rootCA.crt'));
+  const upstream = https.createServer({ key, cert }, (req, res) => {
+    res.writeHead(200, {
+      'Content-Type': 'text/plain',
+      'Content-Length': '4',
+    });
+    res.end('pong');
+  });
+  const proxyPort = await util.getFreePort();
+  const proxy = new ProxyServer({
+    port: proxyPort,
+    dangerouslyIgnoreUnauthorized: true,
+    rule: {
+      *beforeDealHttpsRequest() {
+        return true;
+      },
+      *beforeSendResponse() {
+        return null;
+      },
+    },
+  });
+
+  try {
+    await new Promise((resolve) => upstream.listen(0, '127.0.0.1', resolve));
+    const upstreamPort = upstream.address().port;
+    await new Promise((resolve, reject) => {
+      proxy.once('ready', resolve);
+      proxy.once('error', reject);
+      proxy.start();
+    });
+
+    const connectReq = http.request({
+      host: '127.0.0.1',
+      port: proxyPort,
+      method: 'CONNECT',
+      path: 'example.test:443',
+    });
+
+    const response = await new Promise((resolve, reject) => {
+      connectReq.once('connect', (res, socket) => {
+        assert.strictEqual(res.statusCode, 200);
+        const tlsSocket = tls.connect({
+          socket,
+          servername: 'example.test',
+          rejectUnauthorized: false,
+        }, () => {
+          tlsSocket.write([
+            'GET /ping HTTP/1.1',
+            `Host: 127.0.0.1:${upstreamPort}`,
+            'Connection: close',
+            '',
+            '',
+          ].join('\r\n'));
+        });
+
+        let data = '';
+        tlsSocket.setEncoding('utf8');
+        tlsSocket.on('data', chunk => {
+          data += chunk;
+        });
+        tlsSocket.once('end', () => resolve(data));
+        tlsSocket.once('error', reject);
+      });
+      connectReq.once('error', reject);
+      connectReq.end();
+    });
+
+    assert.match(response, /^HTTP\/1\.1 200 OK/i);
+    assert.match(response, /\r\n\r\npong$/);
+  } finally {
+    await proxy.close();
+    await new Promise(resolve => upstream.close(resolve));
+  }
+}
+
 async function run() {
   testHttpsServerSecureOptionsDisableSslv3AndTlsv1();
   console.log('PASS testHttpsServerSecureOptionsDisableSslv3AndTlsv1');
@@ -161,8 +282,12 @@ async function run() {
   console.log('PASS testRequestHandlerStoresTimeoutConfig');
   testProxyServerPassesTimeoutToRequestHandler();
   console.log('PASS testProxyServerPassesTimeoutToRequestHandler');
+  testEnsureRootCAReplacesMismatchedCache();
+  console.log('PASS testEnsureRootCAReplacesMismatchedCache');
   await testConnectHeadWebSocketUsesLocalProxy();
   console.log('PASS testConnectHeadWebSocketUsesLocalProxy');
+  await testMitmConnectForwardsHttpsRequest();
+  console.log('PASS testMitmConnectForwardsHttpsRequest');
 }
 
 run().catch((error) => {

[jayli]

提示词，qwen3.7-max 搞不定，gpt-5.5 搞定了：

新分支 mitm-ok-with-remove-anyproxy 已创建并推送到github上，版本是 d493769
这个分支是修复了 mitm 在 youtube app 里不可用的问题。

另外一个分支 mitm-perf-version 是带伤迭代的一个分支，目的是为了优化 mitm 的速度，youtube app
里的 mitm 是不成功的，打开 youtube app 加载不出东西。

两个分支共同的起点都是b08986f192c5ae3c8f245bc6b4ed3e3f194644d7

现在，我希望在mitm-ok-with-remove-anyproxy 分支上做进一步的 mitm 迭代优化，即，在
d493769 这个版本的基础上，将 mitm-perf-version 对比 b08986f
的修改增加的 mitm 优化的逻辑和功能应用过来，当前代码即在 mitm-ok-with-remove-anyproxy 这个分支上

你应当能聪明的分辨 mitm-perf-version 中有用的部分和对 youtube app mitm 问题的继承的部分，
把有用的部分应用过来，如果在证书格式、规格、加密算法上有冲突的话，就以我在mitm-ok-with-remove-anyproxy
这个分支里的修复为主，mitm 的优化更多的是 证书的预生成的大逻辑，在确保证书预生成逻辑的前提下，尽可能
不要破坏mitm-ok-with-remove-anyproxy对证书mitm问题的修复。

[jayli]

d493769

这次提交是恢复到刚完成 去 anyproxy 改造后，补充修 了 mitm 不可用的问题，mitm 不可用的问题就是 去 anyproxy 引入的，这次提交完成后，算是将 去 anyproxy 这件事彻底搞定了

然后跟进 mitm 性能优化的修复

6d63c9e

这次提交，在去 anyproxy 依赖的基础上，将mitm-perf-version 带伤优化的部分也整合了进来，mitm 也ok，mitm 的优化也ok了。

[jayli]

mitm-ok-with-remove-anyproxy vs mitm-perf-version 分支详细对比

两个分支的共同祖先是 b08986f（Merge PR #35 - 去 AnyProxy 依赖）。

独有提交

mitm-ok-with-remove-anyproxy（好分支，+2 commits）	mitm-perf-version（不好分支，+13 commits）
d493769 fix(mitm): rootCA 同步 + response header 修复	0f69627 ~ 4de783a ECDSA P-256 证书生命周期实现
6d63c9e perf(mitm): 预热 + 验证证书缓存（保守方案）	00ef3af MITM cert-lifecycle 集成
	7bb27ff Merge worktree-mitm-cert-optimization
	0c50956 ~ ea2b915 pnpm 文档强调
	fddf981 ~ aaac654 版本号、.npmignore、dockerignore 等杂项
	53b481c 40395b0 add all（不规范的提交）

---

核心差异对比

1. 证书生成方式（最根本的差异）

维度	mitm-perf-version（不好）	mitm-ok-with-remove-anyproxy（好）
叶子证书算法	ECDSA P-256（椭圆曲线）	RSA 2048（传统）
生成器	@peculiar/x509 + crypto.webcrypto.subtle（自己实现 X.509 生成流水线）	node-easy-cert（保持原有生成器，加 lifecycle 包装层）
额外依赖	@peculiar/x509、reflect-metadata	无新增（沿用 node-easy-cert）
证书文件名	SHA256 hash + .json 元数据文件（{safeId}.key, {safeId}.crt, {safeId}.json）	域名直接命名（example.com.key, example.com.crt），无元数据
兼容性风险	ECDSA 叶子证书可能与某些客户端/中间件不兼容（改变了原有格式）	完全兼容原有 RSA 2048 格式，YouTube MITM 等规则无需调整

2. RootCA 管理

维度	mitm-perf-version（不好）	mitm-ok-with-remove-anyproxy（好）
init 参数	需传 rootCAKeyPath、rootCACertPath、loadConfig 等 5 个参数	只需 certDir + mitmRegistry，其余自动推导
rootCA 定位	硬编码指向 cert/rootCA.crt	委托给 node-easy-cert 的 isRootCAFileExists() / getRootCAFilePath()
generateRootCA	直接报错 "Static rootCA is missing"	真正调用 node-easy-cert.generateRootCA() 可动态生成
ensureRootCA 同步	只检查文件是否存在，存在就跳过	比对指纹（fingerprint256），指纹不同则替换 + 清理所有旧域名证书缓存

3. 证书存储目录

维度	mitm-perf-version（不好）	mitm-ok-with-remove-anyproxy（好）
certDir	项目本地 ./certificates/	~/.anyproxy/certificates/（与 node-easy-cert 共享）
util.getAnyProxyPath	被改为指向 ../../certificates/（项目内）	保持原始 ~/.anyproxy/ 路径

4. 预热并发

维度	mitm-perf-version（不好）	mitm-ok-with-remove-anyproxy（好）
prewarmCerts	串行 for...of await，一个接一个	并发 worker pool，默认 concurrency=4

5. 健康检查（healthCheck）

维度	mitm-perf-version（不好）	mitm-ok-with-remove-anyproxy（好）
遍历方式	只扫描 .json 元数据文件，从中提取 hostname/safeId	直接扫描 .crt 文件，从文件名推导 hostname
容错性	元数据文件丢失或损坏则该证书无法被检查	无元数据依赖，更健壮

6. 缓存验证（validateCache）

维度	mitm-perf-version（不好）	mitm-ok-with-remove-anyproxy（好）
算法校验	检查 ec + prime256v1	检查 rsa + modulusLength === 2048
key/cert 匹配	手动比较 DER 编码的公钥字节	依赖 leaf.verify(root.publicKey) + tls.createSecureContext

7. 启动流程（proxy.js）

维度	mitm-perf-version（不好）	mitm-ok-with-remove-anyproxy（好）
rootCA 缺失时	打印错误并 return，不启动代理	调用 certMgr.generateRootCA() 动态生成后继续启动
调试日志	无	request-handler.js 中增加了 [DEBUG-REQ] 日志（辅助排查 response header 问题）

8. 工程/文档差异

维度	mitm-perf-version（不好）	mitm-ok-with-remove-anyproxy（好）
版本号	0.1.24	0.1.23
package.json 依赖	多 @peculiar/x509、reflect-metadata	少两个依赖，更干净
CLAUDE.md	添加了严格的 pnpm 规范段落、新增测试命令文档	保持原有简洁风格
.npmignore	有（67 行）	无
build/ 产物	有更新（新的 js bundle）	未更新
docs/superpowers/	有计划/设计文档（~1000 行）	已删除（不需要保留）
提交质量	有 add all 不规范提交	提交清晰、每个 commit 有明确目的

---

共同点

共同特性	说明
去 AnyProxy 依赖	两个分支都基于 b08986f（proxy-core 本地化），不再依赖 @bachi/anyproxy
证书生命周期架构	都有 cert-lifecycle.js 模块：init → ensureCert → validateCache → prewarm → healthCheck → invalidateCert
hostname 归一化	相同的 normalizeHostname()：去端口、去尾部点、IPv6 括号处理、domainToASCII
并发去重	都用 pendingCerts Map 避免同一域名重复生成
SNI 自愈	都在 https-server-mgr.js 的 tls.createSecureContext 失败时调用 invalidateCert() + 清除 LRU
启动预热	都在 proxy ready 后异步执行健康检查 + 预热，不阻塞代理启动
预热域名来源	都从 mitmRegistry.getEnabledRules() 的 host + block_hosts 配置收集
cert-mgr facade	都保留旧的 callback API（getCertificate(hostname, cb)）兼容 proxy-server.js
LRU delete	都给 https-server-mgr.js 的 LRU 缓存加了 delete(key) 方法

---

总结

核心分歧就一个：证书生成方式。

• mitm-perf-version 用 @peculiar/x509 自己实现了 ECDSA P-256 证书生成流水线，是一个激进的优化——改了证书算法、改了存储格式、改了目录结构、加了两个新依赖。但引入了兼容性风险（ECDSA 叶子证书），且 ensureRootCA 没有指纹比对导致 rootCA 变更后旧证书不会自动清理。

• mitm-ok-with-remove-anyproxy 走保守路线——保持 node-easy-cert 的 RSA 2048 生成器不变，只在其上加了一层 lifecycle 管理（预热、验证、自愈、去重）。同时修复了 ensureRootCA 的指纹同步问题和 response header mutation bug。更少的依赖、更小的改动面、更好的兼容性。

最终 6d63c9e 在好分支上整合了 perf 分支中有价值的部分（预热、健康检查、并发去重、SNI 自愈），同时保持 RSA 2048 兼容性和所有 bugfix。