block-proxy 0.1.7 → 0.1.9

package/socks5/server.js

@@ -113,6 +113,8 @@ async function init() {
     }
 
     function handleTcpRequest(clientSocket, targetHost, targetPort) {
+      // jayli
+      // console.log(targetHost);
       clientSocket.setTimeout(30_000);
       clientSocket.on('timeout', () => clientSocket.destroy());
 
@@ -160,13 +162,199 @@ async function init() {
       clientSocket.on('close', () => proxySocket.destroy());
     }
 
-    // 处理 UDP ASSOCIATE（本地 UDP 中继）
+    // 处理 UDP ASSOCIATE（RFC 1928 合规实现）
     function handleUdpAssociate(clientSocket) {
       const udpRelay = dgram.createSocket('udp4');
+      let clientUdpAddr = null; // 客户端的 UDP 地址（用于回包）
+
+      // 存储 { 'host:port': { rinfo } } 用于回包时知道发给谁
+      const targetToClientMap = new Map();
+
+      // 绑定到任意端口
+      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);
+        }
+      });
+
+      // 接收从目标服务器返回的 UDP 响应，并转发回客户端
+      udpRelay.on('listening', () => {
+        // Node.js 不会自动监听入站响应，但我们已经在 bind 后处于 listening 状态
+        // 所有 inbound UDP 都会触发 'message'，包括响应
+      });
+
+      // 注意：响应包也会触发 'message'，但来源是外部服务器（不是 clientUdpAddr）
+      // 所以我们需要在上面的逻辑中区分：如果是来自已知 target 的响应，则回包
+
+      // 重写 message handler 以同时处理“客户端请求”和“服务器响应”
+      // 我们已经做了：所有包都进同一个 handler，通过 targetToClientMap 判断是否是响应
+
+      // 但我们还需要：当收到外部服务器的响应时，把它封装后发回 clientUdpAddr
+      // 所以上面的 handler 已经能处理请求，现在补充响应回包逻辑：
+
+      // 实际上，上面的 handler 只处理了“客户端 → 代理”的包。
+      // “目标服务器 → 代理”的包也会进同一个 handler，但此时 rinfo ≠ clientUdpAddr，
+      // 且不在 targetToClientMap 的 key 中（因为 key 是 host:port，而 rinfo 是源地址）。
+
+      // 所以我们需要换一种方式：**为每个目标创建独立的 socket？**
+      // 但那样太重。更高效的做法是：**用单个 relay socket，靠 targetToClientMap 映射**
+
+      // ✅ 正确做法：在收到外部响应时，根据 (rinfo.address:rinfo.port) 查找是否是我们发出的请求的目标
+      // 但注意：我们发的是 targetHost:targetPort，而响应来自 same address:port
+
+      // 所以我们在发送时，应该用 **rinfo.address:rinfo.port 作为 key 存 clientAddr**
+      // 但这样不行，因为多个客户端可能访问同一目标。
+
+      // 🚨 更健壮的方式：**每个客户端有自己的 udpRelay**（当前就是这么做的！）
+      // 所以在这个函数内，所有流量都属于同一个 SOCKS5 TCP 会话的客户端。
+      // 因此，我们可以安全地假设：**任何非 clientUdpAddr 的 UDP 包都是目标服务器的响应**
+
+      // 修改 message handler 如下（替换上面的 handler）：
+      udpRelay.removeAllListeners('message');
       udpRelay.on('message', (msg, rinfo) => {
-        // 注意：标准 SOCKS5 UDP 包含 header，但此处简化直接回传（适用于 DNS 等）
-        // 生产环境建议按 RFC 1928 封装/解封装
-        clientSocket.write(msg);
+        // 判断是客户端发来的请求，还是目标服务器的响应
+        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;
+
+          const atyp = msg[3];
+          let headerLen = 0, targetHost, targetPort;
+
+          try {
+            if (atyp === 0x01) {
+              targetHost = msg.slice(4, 8).join('.');
+              targetPort = msg.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);
+              headerLen = 5 + len + 2;
+            } else if (atyp === 0x04) {
+              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;
+
+            // 发送到目标
+            udpRelay.send(payload, targetPort, targetHost, (err) => {
+              if (err) {
+                console.warn(`UDP send error to ${targetHost}:${targetPort}:`, err.message);
+              }
+            });
+          } catch (e) {
+            console.warn('UDP request 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) => {
@@ -174,17 +362,16 @@ async function init() {
         clientSocket.destroy();
       });
 
-      const localAddr = udpRelay.address();
-      // 告诉客户端 UDP 中继地址（返回 127.0.0.1 + 端口）
-      sendResponse(clientSocket, 0x00, 0x01, '127.0.0.1', localAddr.port);
-
       // 清理
-      clientSocket.on('close', () => udpRelay.close());
-      clientSocket.on('error', () => udpRelay.close());
+      const cleanup = () => {
+        if (!udpRelay._closed) {
+          udpRelay.close();
+        }
+      };
+      clientSocket.on('close', cleanup);
+      clientSocket.on('error', cleanup);
     }
 
-    // console.log('ticketKeys length:', ticketKeys.length); // 必须是 48！
-
     // TLS 服务器选项
     const tlsOptions = {
       key: TLS_KEY,
@@ -297,13 +484,13 @@ async function init() {
           socket.destroy();
         }
       } catch (err) {
-        console.error('SOCKS5 over TLS session error:', err.message);
+        console.error('SOCKS5 over TLS session error:', err);
         socket.destroy();
       }
     });
 
     server.on('clientError', (err, socket) => {
-      console.warn('TLS client error during handshake:', err.message);
+      console.warn('TLS client error during handshake:', err);
       socket?.end(); // 安全关闭
     });
 

package/src/App.css

@@ -271,9 +271,11 @@ span.host-text {
 }
 
 .setting-row label {
-  /*width: 120px;*/
+  width: 220px; /* 固定宽度，足够容纳最长的标签 */
+  text-align: right;
   font-weight: bold;
   color: #555;
+  flex-shrink: 0; /* 防止被压缩 */
 }
 
 .setting-row input {

package/src/App.js

@@ -541,7 +541,7 @@ function App() {
                         onChange={(e) => updateFilterTime(index, e.target.value, getFilterTimes(host).end)}
                       />
                     </label>
-                    <label>~</label>
+                    <label>～</label>
                     <label>
                       <input
                         type="time"
@@ -564,7 +564,6 @@ function App() {
         
         <div className="config-section">
           <h2>HTTP/Socks5 端口设置，验证信息，下游 VPN_Proxy 代理</h2>
-          {/*<p><span>配置页端口默认 8004</span></p> */}
           <div className="setting-row">
             <label>Anyproxy HTTP 代理端口:</label>
             <input
@@ -594,38 +593,38 @@ function App() {
           <div className="setting-row">
             <label>代理用户名:</label>
             <input
-              type="string"
+              type="text"
               value={config.auth_username}
               onChange={(e) => setConfig({...config, auth_username: e.target.value || ""})}
             />
           </div>
           <div className="setting-row">
-            <label>代理密码:&nbsp;&nbsp;&nbsp;&nbsp;</label>
+            <label>代理密码:</label>
             <input
-              type="string"
+              type="text"
               value={config.auth_password}
               onChange={(e) => setConfig({...config, auth_password: e.target.value || ""})}
             />
           </div>
 
-          <div className="setting-row">
+          <div className="setting-row full-width">
             <label>公网域名:</label>
-            <div>如果要公网可访问，OpenWRT 配置相同的端口转发到 AnyProxy 代理端口，这里写公网域名<br />（仅在浏览器通过公网域名+端口查看系统水位时防止回环）</div>
             <input
               type="text"
               value={config.your_domain}
               onChange={(e) => setConfig({...config, your_domain: e.target.value || ""})}
             />
+            <div className="help-text">如果要公网可访问，OpenWRT 配置相同的端口转发到 AnyProxy 代理端口，这里写公网域名<br />（仅在浏览器通过公网域名+端口查看系统水位时防止回环）</div>
           </div>
 
-          <div className="setting-row">
+          <div className="setting-row full-width">
             <label>VPN_PROXY 设置（留空）:</label>
-            <div>（格式：“127.0.0.1:1087”，仅调试用）</div>
             <input
               type="text"
               value={config.vpn_proxy}
               onChange={(e) => setConfig({...config, vpn_proxy: e.target.value || ""})}
             />
+            <div className="help-text">（格式：“127.0.0.1:1087”，仅调试用）</div>
           </div>
           <div className="setting-row actions">
             <button 

package/tools/speed_test.sh

@@ -0,0 +1,121 @@
+#!/usr/bin/env sh
+
+# --- 参数检查 ---
+if [ $# -eq 0 ]; then
+    echo "用法: $0 <URL> [TARGET_IP]"
+    echo "说明: 若提供 TARGET_IP，则绕过 DNS，直连该 IP 并使用 URL 中的域名作为 SNI/Host"
+    echo "示例:"
+    echo "  $0 https://www.taobao.com"
+    echo "  $0 https://www.taobao.com 211.100.8.95"
+    exit 1
+fi
+
+URL="$1"
+TARGET_IP="${2:-}"  # 第二个参数可选
+PROXY="socks5://127.0.0.1:1081"
+TUNNEL_PID=""
+SOCAT_LOG="/tmp/socat_error.log"
+
+# --- 从 URL 提取主机名（用于 --resolve 和 SNI）---
+# 移除协议头，再截断路径和端口
+HOST=$(echo "$URL" | sed -E 's|^[^:]+://||' | sed -E 's|/.*$||' | sed -E 's/:.*$//')
+PORT="443"
+
+cleanup() {
+    if [ -n "$TUNNEL_PID" ]; then
+        # 检查进程是否存在
+        if kill -0 "$TUNNEL_PID" 2>/dev/null; then
+            echo "" >&2
+            # echo "🛑 正在终止 socat 隧道 (PID: $TUNNEL_PID)..." >&2
+            kill "$TUNNEL_PID" 2>/dev/null
+
+            # 等待最多 1 秒让它优雅退出
+            i=0
+            while kill -0 "$TUNNEL_PID" 2>/dev/null && [ $i -lt 10 ]; do
+                sleep 0.1
+                i=$((i + 1))
+            done
+
+            # 如果还在，强制杀死
+            if kill -0 "$TUNNEL_PID" 2>/dev/null; then
+                echo "⚠️  强制终止 socat..." >&2
+                kill -9 "$TUNNEL_PID" 2>/dev/null
+            fi
+
+            # 清理僵尸进程
+            wait "$TUNNEL_PID" 2>/dev/null
+        fi
+    fi
+    rm -f "$SOCAT_LOG"
+    exit "${1:-0}"
+}
+
+trap cleanup EXIT INT TERM
+
+# --- 检查本地端口 1081 是否已被占用 ---
+if command -v ss >/dev/null 2>&1; then
+    if ss -tuln 2>/dev/null | grep -q ':1081\b'; then
+        echo "⚠️  警告: 本地端口 1081 已被占用，socat 可能启动失败。"
+    fi
+elif command -v netstat >/dev/null 2>&1; then
+    if netstat -tuln 2>/dev/null | grep -q ':1081\b'; then
+        echo "⚠️  警告: 本地端口 1081 已被占用，socat 可能启动失败。"
+    fi
+fi
+
+# --- 启动 socat 隧道，并记录错误 ---
+echo "🔌 正在启动隧道: socat → OPENSSL:yui.cool:8002 ..."
+socat TCP-LISTEN:1081,fork,bind=127.0.0.1 OPENSSL:yui.cool:8002,verify=0 >"$SOCAT_LOG" 2>&1 &
+TUNNEL_PID=$!
+sleep 0.5
+
+# --- 检查 socat 是否仍在运行 ---
+if ! kill -0 "$TUNNEL_PID" 2>/dev/null; then
+    echo "❌ 隧道启动失败！socat 报错如下："
+    if [ -s "$SOCAT_LOG" ]; then
+        cat "$SOCAT_LOG"
+    else
+        echo "（无详细错误，可能进程立即崩溃）"
+    fi
+    exit 1
+else
+    : > "$SOCAT_LOG"  # 清空日志
+fi
+
+# --- 构建 curl 命令 ---
+CURL_CMD="curl -k -I --proxy '$PROXY'"
+
+if [ -n "$TARGET_IP" ]; then
+    CURL_CMD="$CURL_CMD --resolve '$HOST:$PORT:$TARGET_IP'"
+    echo "🌐 绕过 DNS: 直连 $TARGET_IP，SNI = $HOST"
+else
+    echo "🌐 使用代理解析 DNS（常规模式）"
+fi
+
+echo "📡 请求: $URL via $PROXY"
+
+# --- 执行 curl 并计时 ---
+FINAL_CMD="$CURL_CMD $URL"
+
+echo "$FINAL_CMD"
+
+{ time_output=$( { time eval "$FINAL_CMD"; } 2>&1 1>&3 ); } 3>&1
+exit_code=$?
+
+# --- 提取状态行 ---
+status_line=$(printf "%s\n" "$time_output" | head -n 1)
+
+if [ "$exit_code" -eq 0 ]; then
+    echo "✅ 响应状态: $status_line"
+else
+    echo "❌ 请求失败（退出码: $exit_code）"
+    [ -n "$status_line" ] && echo "⚠️  部分响应: $status_line"
+fi
+
+# --- 显示耗时 ---
+real_time=$(printf "%s\n" "$time_output" | grep "^real" | awk '{print $2}')
+if [ -n "$real_time" ]; then
+    echo "⏱️  耗时: $real_time"
+else
+    echo "⚠️  无法获取耗时（shell 不支持 time 内置命令的格式）"
+fi