block-proxy 0.1.14 → 0.1.16

package/socks5/server.js

@@ -162,211 +162,118 @@ async function init() {
       clientSocket.on('close', () => proxySocket.destroy());
     }
 
-    // 处理 UDP ASSOCIATE（RFC 1928 合规实现）
+    // 处理 UDP ASSOCIATE（UDP over TCP 隧道模式）
+    // 客户端通过 TLS TCP 连接发送帧格式的 UDP 数据：[2字节大端长度][SOCKS5 UDP payload]
+    // 服务端解帧后用 dgram 发出真实 UDP，响应封帧回传
     function handleUdpAssociate(clientSocket) {
-      const udpRelay = dgram.createSocket('udp4');
-      let clientUdpAddr = null; // 客户端的 UDP 地址（用于回包）
+      sendResponse(clientSocket, 0x00);
 
-      // 存储 { 'host:port': { rinfo } } 用于回包时知道发给谁
-      const targetToClientMap = new Map();
+      const udpSocket = dgram.createSocket('udp4');
+      let buffer = Buffer.alloc(0);
+      let idleTimer = null;
+      const UDP_IDLE_TIMEOUT = 120_000;
 
-      // 绑定到任意端口
-      udpRelay.bind(0, '127.0.0.1', () => {
-        const localAddr = udpRelay.address();
-        // 告诉客户端 UDP 中继地址（必须是 127.0.0.1 或公网 IP，不能是 0.0.0.0）
-        sendResponse(clientSocket, 0x00, 0x01, '127.0.0.1', localAddr.port);
-      });
-
-      // 接收来自客户端的 UDP 包（带 SOCKS5 header）
-      udpRelay.on('message', (msg, rinfo) => {
-        if (!clientUdpAddr) {
-          // 第一个包来自客户端，记录其地址（后续回包用）
-          clientUdpAddr = rinfo;
-        }
-
-        if (msg.length < 10) {
-          // 最小 UDP 请求：VER=0 + RSV=0 + FRAG=0 + ATYP=1 (IPv4) + ADDR(4) + PORT(2) = 10
-          return;
-        }
-
-        const ver = msg[0];
-        const frag = msg[2]; // 分片不支持
-        if (ver !== 0x00 || frag !== 0x00) {
-          return; // 不支持分片或错误版本
-        }
-
-        try {
-          const atyp = msg[3];
-          let headerLen = 0;
-          let targetHost, targetPort;
-
-          if (atyp === 0x01) {
-            // IPv4
-            targetHost = msg.slice(4, 8).join('.');
-            targetPort = msg.readUInt16BE(8);
-            headerLen = 10;
-          } else if (atyp === 0x03) {
-            // Domain
-            const len = msg[4];
-            if (msg.length < 5 + len + 2) return;
-            targetHost = msg.slice(5, 5 + len).toString();
-            targetPort = msg.readUInt16BE(5 + len);
-            headerLen = 5 + len + 2;
-          } else if (atyp === 0x04) {
-            // IPv6 —— 简化：只取原始字节，Node.js dgram 支持字符串格式
-            if (msg.length < 22) return;
-            const ipv6Bytes = msg.slice(4, 20);
-            targetHost = '[' + ipv6Bytes.reduce((acc, byte, i) => {
-              if (i % 2 === 0 && i > 0) acc += ':';
-              return acc + byte.toString(16).padStart(2, '0');
-            }, '').replace(/(^|:)0+([0-9a-f]+)/g, '$1$2') + ']';
-            targetPort = msg.readUInt16BE(20);
-            headerLen = 22;
-          } else {
-            return; // 不支持的地址类型
-          }
-
-          const payload = msg.slice(headerLen);
-          if (payload.length === 0) return;
-
-          // 构建目标唯一键（用于回包映射）
-          const targetKey = `${targetHost}:${targetPort}`;
-
-          // 创建临时 socket 发送数据（避免端口复用问题）
-          const outSocket = dgram.createSocket('udp4');
-          outSocket.send(payload, targetPort, targetHost, (err) => {
-            if (err) {
-              console.warn(`UDP forward error to ${targetHost}:${targetPort}:`, err.message);
-            }
-            outSocket.close();
-          });
-
-          // 记录该目标对应的客户端地址（用于响应包回传）
-          targetToClientMap.set(targetKey, rinfo);
-
-          // 可选：加个超时自动清理（简化起见这里省略，靠 close 清理）
-        } catch (e) {
-          console.warn('UDP parse error:', e.message);
-        }
-      });
+      function resetIdleTimer() {
+        if (idleTimer) clearTimeout(idleTimer);
+        idleTimer = setTimeout(() => {
+          clientSocket.destroy();
+        }, UDP_IDLE_TIMEOUT);
+      }
 
-      // 接收从目标服务器返回的 UDP 响应，并转发回客户端
-      udpRelay.on('listening', () => {
-        // Node.js 不会自动监听入站响应，但我们已经在 bind 后处于 listening 状态
-        // 所有 inbound UDP 都会触发 'message'，包括响应
+      resetIdleTimer();
+
+      udpSocket.on('message', (msg, rinfo) => {
+        if (clientSocket.destroyed) return;
+        resetIdleTimer();
+
+        // 构建 SOCKS5 UDP response header（源地址填入 rinfo）
+        const addrParts = rinfo.address.split('.');
+        const header = Buffer.alloc(10);
+        header[0] = 0x00; // RSV
+        header[1] = 0x00; // RSV
+        header[2] = 0x00; // FRAG
+        header[3] = 0x01; // ATYP = IPv4
+        header[4] = parseInt(addrParts[0]);
+        header[5] = parseInt(addrParts[1]);
+        header[6] = parseInt(addrParts[2]);
+        header[7] = parseInt(addrParts[3]);
+        header.writeUInt16BE(rinfo.port, 8);
+
+        const payload = Buffer.concat([header, msg]);
+        const frame = Buffer.alloc(2 + payload.length);
+        frame.writeUInt16BE(payload.length, 0);
+        payload.copy(frame, 2);
+        clientSocket.write(frame);
       });
 
-      // 注意：响应包也会触发 'message'，但来源是外部服务器（不是 clientUdpAddr）
-      // 所以我们需要在上面的逻辑中区分：如果是来自已知 target 的响应，则回包
-
-      // 重写 message handler 以同时处理“客户端请求”和“服务器响应”
-      // 我们已经做了：所有包都进同一个 handler，通过 targetToClientMap 判断是否是响应
-
-      // 但我们还需要：当收到外部服务器的响应时，把它封装后发回 clientUdpAddr
-      // 所以上面的 handler 已经能处理请求，现在补充响应回包逻辑：
-
-      // 实际上，上面的 handler 只处理了“客户端 → 代理”的包。
-      // “目标服务器 → 代理”的包也会进同一个 handler，但此时 rinfo ≠ clientUdpAddr，
-      // 且不在 targetToClientMap 的 key 中（因为 key 是 host:port，而 rinfo 是源地址）。
-
-      // 所以我们需要换一种方式：**为每个目标创建独立的 socket？**
-      // 但那样太重。更高效的做法是：**用单个 relay socket，靠 targetToClientMap 映射**
+      clientSocket.on('data', (chunk) => {
+        resetIdleTimer();
+        buffer = Buffer.concat([buffer, chunk]);
 
-      // ✅ 正确做法：在收到外部响应时，根据 (rinfo.address:rinfo.port) 查找是否是我们发出的请求的目标
-      // 但注意：我们发的是 targetHost:targetPort，而响应来自 same address:port
-
-      // 所以我们在发送时，应该用 **rinfo.address:rinfo.port 作为 key 存 clientAddr**
-      // 但这样不行，因为多个客户端可能访问同一目标。
+        while (buffer.length >= 2) {
+          const frameLen = buffer.readUInt16BE(0);
+          if (frameLen === 0 || frameLen > 65535) {
+            clientSocket.destroy();
+            return;
+          }
+          if (buffer.length < 2 + frameLen) break;
 
-      // 🚨 更健壮的方式：**每个客户端有自己的 udpRelay**（当前就是这么做的！）
-      // 所以在这个函数内，所有流量都属于同一个 SOCKS5 TCP 会话的客户端。
-      // 因此，我们可以安全地假设：**任何非 clientUdpAddr 的 UDP 包都是目标服务器的响应**
+          const payload = buffer.slice(2, 2 + frameLen);
+          buffer = buffer.slice(2 + frameLen);
 
-      // 修改 message handler 如下（替换上面的 handler）：
-      udpRelay.removeAllListeners('message');
-      udpRelay.on('message', (msg, rinfo) => {
-        // 判断是客户端发来的请求，还是目标服务器的响应
-        if (clientUdpAddr && rinfo.address === clientUdpAddr.address && rinfo.port === clientUdpAddr.port) {
-          // ← 来自客户端的请求（带 header）
-          if (msg.length < 10) return;
-          const ver = msg[0];
-          const frag = msg[2];
-          if (ver !== 0x00 || frag !== 0x00) return;
+          if (payload.length < 10) continue;
+          if (payload[0] !== 0x00 || payload[1] !== 0x00) continue;
+          if (payload[2] !== 0x00) continue; // 不支持分片
 
-          const atyp = msg[3];
-          let headerLen = 0, targetHost, targetPort;
+          const atyp = payload[3];
+          let targetHost, targetPort, headerLen;
 
           try {
             if (atyp === 0x01) {
-              targetHost = msg.slice(4, 8).join('.');
-              targetPort = msg.readUInt16BE(8);
+              targetHost = payload.slice(4, 8).join('.');
+              targetPort = payload.readUInt16BE(8);
               headerLen = 10;
             } else if (atyp === 0x03) {
-              const len = msg[4];
-              if (msg.length < 5 + len + 2) return;
-              targetHost = msg.slice(5, 5 + len).toString();
-              targetPort = msg.readUInt16BE(5 + len);
+              const len = payload[4];
+              if (payload.length < 5 + len + 2) continue;
+              targetHost = payload.slice(5, 5 + len).toString();
+              targetPort = payload.readUInt16BE(5 + len);
               headerLen = 5 + len + 2;
             } else if (atyp === 0x04) {
-              if (msg.length < 22) return;
-              const ipv6Bytes = msg.slice(4, 20);
+              if (payload.length < 22) continue;
+              const ipv6Bytes = payload.slice(4, 20);
               targetHost = '[' + ipv6Bytes.reduce((acc, byte, i) => {
                 if (i % 2 === 0 && i > 0) acc += ':';
                 return acc + byte.toString(16).padStart(2, '0');
               }, '').replace(/(^|:)0+([0-9a-f]+)/g, '$1$2') + ']';
-              targetPort = msg.readUInt16BE(20);
+              targetPort = payload.readUInt16BE(20);
               headerLen = 22;
             } else {
-              return;
+              continue;
             }
 
-            const payload = msg.slice(headerLen);
-            if (payload.length === 0) return;
+            const data = payload.slice(headerLen);
+            if (data.length === 0) continue;
 
-            // 发送到目标
-            udpRelay.send(payload, targetPort, targetHost, (err) => {
+            udpSocket.send(data, targetPort, targetHost, (err) => {
               if (err) {
-                console.warn(`UDP send error to ${targetHost}:${targetPort}:`, err.message);
+                console.warn(`UDP forward error to ${targetHost}:${targetPort}:`, err.message);
               }
             });
           } catch (e) {
-            console.warn('UDP request parse error:', e.message);
+            console.warn('UDP frame parse error:', e.message);
           }
-        } else {
-          // ← 来自目标服务器的响应（裸 payload），需要封装后发回客户端
-          if (!clientUdpAddr) return; // 还没收到客户端请求
-
-          // 构建 SOCKS5 UDP response header
-          const respHeader = Buffer.alloc(10);
-          respHeader[0] = 0x00; // RSV
-          respHeader[1] = 0x00; // RSV
-          respHeader[2] = 0x00; // FRAG
-          respHeader[3] = 0x01; // ATYP = IPv4 (简化：统一返回 IPv4 0.0.0.0)
-          respHeader[4] = 0;
-          respHeader[5] = 0;
-          respHeader[6] = 0;
-          respHeader[7] = 0;
-          respHeader.writeUInt16BE(rinfo.port, 8); // 源端口作为 DST.PORT（部分客户端依赖）
-
-          const response = Buffer.concat([respHeader, msg]);
-          udpRelay.send(response, clientUdpAddr.port, clientUdpAddr.address, (err) => {
-            if (err) {
-              console.warn('UDP send back to client error:', err.message);
-            }
-          });
         }
       });
 
-      udpRelay.on('error', (err) => {
-        console.error('UDP relay error:', err);
+      udpSocket.on('error', (err) => {
+        console.warn('UDP socket error:', err.message);
         clientSocket.destroy();
       });
 
-      // 清理
       const cleanup = () => {
-        if (!udpRelay._closed) {
-          udpRelay.close();
-        }
+        if (idleTimer) clearTimeout(idleTimer);
+        try { udpSocket.close(); } catch (e) {}
       };
       clientSocket.on('close', cleanup);
       clientSocket.on('error', cleanup);

package/wiki.md

@@ -0,0 +1,287 @@
+# Block-Proxy Wiki
+
+## 1）Docker 构建与发布
+
+### 构建命令
+
+| 命令 | 说明 |
+|:-----|:------|
+| `npm run docker:build` | 本地构建 amd64 镜像 |
+| `npm run docker:build:arm` | 本地构建 arm64 镜像 |
+| `npm run docker:push` | 构建并推送 amd64 + arm64 双架构到 ACR |
+| `npm run docker:push:amd64` | 仅推送 amd64 |
+| `npm run docker:push:arm64` | 仅推送 arm64 |
+
+### 首次推送前登录 ACR
+
+```bash
+docker login --username=hi50078584@aliyun.com crpi-x1zji86f6jpcd7t1.cn-hangzhou.personal.cr.aliyuncs.com
+```
+
+> 如果打包时磁盘空间不够：`docker system prune -a --volumes`
+
+### Docker 部署 - host 网络模式（推荐）
+
+网关里为了方便获取子网机器 IP 和 MAC 地址，容器需要和宿主机共享同一个网络：
+
+```bash
+docker run --init -d --restart=unless-stopped \
+  -e TZ=Asia/Shanghai --network=host \
+  --user=root \
+  --log-driver local \
+  --log-opt max-size=10m \
+  --log-opt max-file=3 \
+  --cpus="5" \
+  --memory 400m \
+  -v "$(pwd)/":/app/config \
+  --name block-proxy \
+  crpi-x1zji86f6jpcd7t1.cn-hangzhou.personal.cr.aliyuncs.com/lijing00333/block-proxy:latest
+```
+
+### 挂载配置文件（config.json 和 rule.js）
+
+Docker 启动命令中的 `-v "$(pwd)/":/app/config` 将宿主机当前目录映射到容器内的 `/app/config`。代理启动时会自动从该目录加载配置。
+
+#### config.json
+
+容器首次启动时，如果挂载目录下没有 `config.json`，代理会自动生成一份默认配置。你也可以预先创建：
+
+```json
+{
+  "block_hosts": [],
+  "proxy_port": 8001,
+  "socks5_port": 8002,
+  "auth_username": "admin",
+  "auth_password": "your-password",
+  "enable_express": "1",
+  "enable_socks5": "1"
+}
+```
+
+配置修改后通过后台面板（`:8003`）保存，或重启容器后生效。
+
+#### rule.js（自定义 MITM 规则）
+
+在挂载目录下创建 `rule.js`，代理启动时会自动加载并与内置规则合并。参照 [`example/rule.js`](https://github.com/jayli/block-proxy/blob/main/example/rule.js) 格式：
+
+```js
+module.exports = {
+  MyRule: [{
+    type: 'beforeSendRequest',
+    host: 'example.com',
+    regexp: '^https?://example\\.com/blocked',
+    callback: async function(url, request, response) {
+      return {
+        response: {
+          statusCode: 403,
+          header: { 'Content-Type': 'text/plain' },
+          body: 'Blocked by custom rule'
+        }
+      };
+    }
+  }]
+};
+```
+
+规则支持两种类型：
+- `beforeSendRequest` — 在请求发出前拦截，可返回本地响应阻断请求
+- `beforeSendResponse` — 在响应返回前修改，可改写响应体
+
+修改 `rule.js` 后需重启容器使规则生效。
+
+> 注意：`config.json` 是运行时配置文件，通过后台面板修改后由代理自动写入。`rule.js` 需要手动编辑，容器只读取不写入。
+
+### Docker 部署 - 端口绑定模式（Windows/Mac）
+
+```bash
+docker run --init -d --restart=unless-stopped --user=root \
+  -v "$(pwd)/":/app/config \
+  -e TZ=Asia/Shanghai -p 8001:8001 -p 8002:8002 \
+  --name block-proxy \
+  crpi-x1zji86f6jpcd7t1.cn-hangzhou.personal.cr.aliyuncs.com/lijing00333/block-proxy:latest
+```
+
+---
+
+## 2）服务端配置
+
+### 端口说明
+
+| 端口 | 说明 | 可否关闭 |
+|:----:|:------|:------:|
+| 3000 | 调试端口（仅 `npm run dev` 时启用） | 生产环境不启用 |
+| 8001 | HTTP 代理端口 | 不可禁用 |
+| 8002 | Socks5 over TLS 代理端口 | 可禁用 |
+| 8003 | 后台配置面板端口 | 可禁用 |
+
+
+### 配置面板
+
+- 后台配置：访问 `http://server-ip:8003`
+- 关闭/启用配置面板：`http://server-ip:8001`
+
+首次启动后访问 `http://代理IP:8001` 根据提示操作。block-proxy 可以配置只启动 proxy 而不启动后台面板。
+
+### 路由表
+
+路由表每两小时自动刷新一次。如果新入网的设备未显示，在后台手动刷新路由表，添加限制条件后点击「重启代理」即可。
+
+---
+
+## 3）客户端配置
+
+### 代理端口
+
+- **8001**：HTTP 代理
+- **8002**：Socks5 over TLS
+
+> ⚠️ Socks5 代理不支持对 MAC 地址的定向拦截，MAC 地址拦截仅对局域网内 HTTP 代理绑定生效。建议局域网绑定 HTTP 代理，公网绑定 Socks5 代理。
+
+> ⚠️ 使用小火箭的 Socks5 over TLS 代理时，TLS 选项中勾选「允许不安全」。
+
+### 证书安装（iOS）
+
+1. 进入后台配置面板，扫码下载证书
+2. 手机设置中安装该证书
+3. 设置 → 通用 → 关于本机 → 证书信任设置 → 打开对 AnyProxy 的完全信任
+
+### 代理设置（iPhone/iPad）
+
+设置 → 无线局域网 → 点击当前网络 → HTTP 代理/配置代理 → 手动 → 填写服务器地址和端口。
+
+### 固定 MAC 地址
+
+如果要通过 MAC 地址拦截小朋友上网，在小朋友设备中把 MAC 地址固定下来（关闭私有 Wi-Fi 地址）：
+
+- iOS：设置 → 无线局域网 → 点击当前网络 → 关闭「私有 Wi-Fi 地址」
+
+### macOS 客户端
+
+提供 SocksClient.app 桌面端连接工具，支持 macOS（M 系列芯片）。
+
+下载地址：[GitHub Release](https://github.com/jayli/block-proxy/releases/latest)
+
+---
+
+## 4）防火墙配置：禁止设备直连
+
+防止小朋友修改 Wi-Fi 连接绕过代理，在网关配置防火墙规则禁止设备直连：
+
+```bash
+iptables -I FORWARD -m mac --mac-source D2:9E:8D:1B:F1:4E -j REJECT
+ip6tables -I forwarding_rule -m mac --mac-source D2:9E:8D:1B:F1:4E -j REJECT
+```
+
+执行后重启防火墙生效。
+
+---
+
+## 5）MITM 规则
+
+### 生效条件
+
+1. 客户端设备必须安装 AnyProxy 证书
+2. 服务需要根据 IP 反查 MAC 地址，需要部署在可扫描子网的节点（推荐 OpenWrt 网关）
+3. 路由表每 2 小时更新一次，新入网设备建议在后台手动刷新并重启代理
+4. 所有拦截规则仅在 HTTP 代理中生效；Socks5 over TLS 是反向代理，MAC 地址拦截只对直连 HTTP 代理生效
+
+### YouTube 去广告
+
+在后台配置中添加以下 4 条 reject 规则：
+
+| 域名 | Match Rule |
+|:-----|:-----------|
+| `youtube.com` | `^https?:\/\/(www\|s)\.youtube\.com\/(pagead\|ptracking)` |
+| `youtube.com` | `^https?:\/\/s\.youtube\.com\/api\/stats\/qoe\?adcontext` |
+| `youtube.com` | `^https?:\/\/(www\|s)\.youtube\.com\/api\/stats\/ads` |
+| `googlevideo.com` | `^https?:\/\/[\w-]+\.googlevideo\.com\/(?!(dclk_video_ads\|videoplayback\?)).+&oad` |
+
+另外两条规则在源码中自动生效：[`proxy/mitm/rule.js`](https://github.com/jayli/block-proxy/blob/main/proxy/mitm/rule.js)。
+
+### 有道词典会员
+
+已内置，无需额外配置。
+
+### 自定义规则
+
+参照 [`example/rule.js`](https://github.com/jayli/block-proxy/blob/main/example/rule.js) 编写配置文件，启动时通过 `-c` 参数加载：
+
+```bash
+block-proxy -c rule.js
+```
+
+---
+
+## 6）开发指南
+
+### 环境准备
+
+```bash
+git clone https://github.com/jayli/block-proxy.git
+cd block-proxy
+pnpm i
+```
+
+### 开发命令
+
+| 命令 | 说明 |
+|:-----|:------|
+| `npm run dev` | 开发模式，启动全部服务（代理 + 后台 + React HMR :3000） |
+| `npm run craco` | 仅启动 React 开发服务器（端口 3000） |
+| `npm run start` | 生产模式启动 |
+| `npm run proxy` | 仅启动代理，不启动后台面板 |
+| `npm run socks5` | 仅启动 Socks5 服务 |
+| `npm run build` | 构建 React 前端 |
+
+### 测试
+
+```bash
+npm run test:proxy   # 代理连通性/性能/吞吐量测试（需先启动代理服务）
+```
+
+### 代码结构
+
+```
+├── proxy/           # 代理核心：AnyProxy 集成、拦截逻辑、MITM 规则
+│   └── mitm/        # MITM 规则定义（YouTube 去广告、有道词典 VIP）
+├── socks5/          # SOCKS5 over TLS 实现
+├── server/          # Express 后台 API + 管理面板
+├── src/             # React 前端（CRA + CRACO）
+├── client/          # macOS 客户端（Python）
+├── test/            # 测试套件
+├── cert/            # TLS/CA 证书
+├── bin/start.js     # CLI 入口（block-proxy 命令）
+└── config.json      # 运行时配置
+```
+
+---
+
+## 7）性能测试
+
+### 并发测试
+
+| 直连 | 代理 |
+|:----:|:----:|
+| <img height="400" alt="直连测试" src="https://github.com/user-attachments/assets/8268bc5c-956f-4b67-89c1-cdd5725114b3" /> | <img height="400" alt="代理测试" src="https://github.com/user-attachments/assets/abf4bfa1-c8b8-4907-ba0e-bcc76e8899fa" /> |
+
+### 网速测试
+
+<img width="544" alt="网速测试" src="https://github.com/user-attachments/assets/67c61e34-67ae-4345-97ca-d266cd35ddf4" />
+
+---
+
+## 8）已知问题
+
+### iOS Safari 安全限制
+
+iOS Safari 不支持带认证的代理与网关使用相同 IP 地址。两种解决方案：
+
+1. 不填写代理认证用户名和密码（留空则验证始终通过）
+2. 给 OpenWrt LAN 口额外绑定一个 IP，iOS 设备使用该 IP 作为代理地址
+
+<img width="300" alt="openwrt IP 绑定" src="https://github.com/user-attachments/assets/0f46d6b4-00b1-44aa-9be7-fa23a09bb199" />
+
+
+## 9）网络拓扑
+
+<img width="600" alt="image" src="https://github.com/user-attachments/assets/2d8a4ec7-8ced-446d-8777-6eaa30e27bc0" />