AI 自测结束

proxy/PROTOCOL.md

@@ -0,0 +1,174 @@
+# 代理通信协议设计文档
+
+## 1. 架构概述
+
+### 1.1 设备角色
+
+| 设备 | 角色 | 能力 | 限制 |
+|------|------|------|------|
+| 电脑A | 代理客户端 | 可访问内网网站 | 无法监听端口 |
+| 电脑B | 代理服务器 | 可监听端口 | 无法直接访问内网 |
+
+### 1.2 网络拓扑
+
+```
+浏览器 <--(端口8081)--> 电脑B <--(端口8080)--> 电脑A <--(内网)--> 目标网站
+```
+
+---
+
+## 2. 端口分配
+
+| 端口号 | 用途 | 连接方向 |
+|--------|------|----------|
+| 8080 | 设备A连接端口 | 电脑A → 电脑B |
+| 8081 | 浏览器访问端口 | 浏览器 → 电脑B |
+
+---
+
+## 3. 通信协议
+
+### 3.1 协议类型
+
+采用 **HTTP CONNECT 代理协议**，这是标准的HTTP隧道协议。
+
+### 3.2 协议流程
+
+#### 阶段1：设备A连接到设备B
+
+```
+电脑A → 电脑B: TCP连接建立
+电脑B → 电脑A: 连接接受（无额外协议，仅TCP握手）
+```
+
+#### 阶段2：浏览器发起请求
+
+```
+浏览器 → 电脑B: HTTP CONNECT请求
+CONNECT zentao.sunyard.com.cn:9788 HTTP/1.1
+Host: zentao.sunyard.com.cn:9788
+[其他请求头...]
+```
+
+#### 阶段3：电脑B转发请求
+
+```
+电脑B → 电脑A: 透传完整HTTP CONNECT请求
+```
+
+#### 阶段4：电脑A建立隧道
+
+```
+电脑A → 内网目标: TCP连接建立
+内网目标 → 电脑A: 连接接受
+电脑A → 电脑B: HTTP 200响应
+HTTP/1.1 200 Connection Established
+```
+
+#### 阶段5：数据隧道
+
+```
+浏览器 ↔ 电脑B ↔ 电脑A ↔ 内网目标: 双向数据流透传
+```
+
+#### 阶段6：连接关闭
+
+任意一端断开连接，整条链路关闭。
+
+---
+
+## 4. 数据格式
+
+### 4.1 HTTP CONNECT 请求格式
+
+```
+CONNECT {目标地址}:{目标端口} HTTP/1.1\r\n
+Host: {目标地址}:{目标端口}\r\n
+[可选请求头]\r\n
+\r\n
+```
+
+### 4.2 HTTP 200 响应格式
+
+```
+HTTP/1.1 200 Connection Established\r\n
+\r\n
+```
+
+---
+
+## 5. 日志规范
+
+### 5.1 日志格式
+
+| 字段 | 格式 | 示例 |
+|------|------|------|
+| 时间戳 | `YYYY-MM-DD HH:MM:SS` | `2024-01-15 10:30:45` |
+| 级别 | `[INFO]` / `[ERROR]` / `[DEBUG]` | `[INFO]` |
+| 来源 | `[Browser]` / `[DeviceA]` / `[System]` | `[Browser]` |
+| 内容 | 描述信息 | 请求详情 |
+
+### 5.2 HTTP请求日志（电脑B）
+
+```
+[时间戳] [INFO] [Browser] {客户端IP}:{端口} - {方法} {URL} - Body: {字节数} bytes
+```
+
+### 5.3 HTTP响应日志（电脑B）
+
+```
+[时间戳] [INFO] [Browser] {客户端IP}:{端口} - {方法} {URL} - Status: {状态码} - Time: {耗时}ms
+```
+
+### 5.4 连接状态日志
+
+```
+[时间戳] [INFO] [DeviceA] Connected: {IP}:{端口}
+[时间戳] [INFO] [DeviceA] Disconnected
+[时间戳] [INFO] [Browser] Connected from: {IP}:{端口}
+[时间戳] [INFO] [Browser] Disconnected: {IP}:{端口}
+```
+
+---
+
+## 6. 错误处理
+
+### 6.1 设备A未连接
+
+当浏览器请求时设备A未连接：
+
+```
+HTTP/1.1 503 Service Unavailable
+Content-Type: text/plain
+
+Device A not connected
+```
+
+### 6.2 目标不可达
+
+当电脑A无法连接目标网站：
+
+```
+HTTP/1.1 502 Bad Gateway
+Content-Type: text/plain
+
+Cannot connect to target
+```
+
+### 6.3 重复连接
+
+当已有设备A连接时，拒绝新连接：
+
+```
+ERROR: Another A device is already connected
+```
+
+---
+
+## 7. 超时设置
+
+| 操作 | 超时时间 |
+|------|----------|
+| 设备A连接超时 | 10秒 |
+| 目标网站连接超时 | 30秒 |
+| 连接空闲超时 | 120秒 |

proxy/proxy_client.py

@@ -2,140 +2,146 @@
 import socket
 import threading
 import sys
+import time
 
-def tunnel_thread(src, dst):
+TARGET_HOST = 'zentao.sunyard.com.cn'
-    """Tunnel thread: continuously forward data"""
+TARGET_PORT = 9788
+
+def log_info(source, message):
+    """Log info message"""
+    timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
+    print("[%s] [INFO] [%s] %s" % (timestamp, source, message))
+
+def log_error(source, message):
+    """Log error message"""
+    timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
+    print("[%s] [ERROR] [%s] %s" % (timestamp, source, message))
+
+def handle_request(b_socket, request_data):
+    """Handle a single request from device B"""
+    # Parse HTTP request
+    request_lines = request_data.split(b"\r\n")
+    if request_lines:
+        first_line = request_lines[0].decode('utf-8', errors='ignore')
+        parts = first_line.split()
+        if len(parts) >= 2:
+            method = parts[0]
+            url = parts[1]
+            log_info("System", "Received request: %s %s" % (method, url))
+    
+    # Connect to target
+    target_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    target_sock.settimeout(30)
+    
+    try:
+        target_sock.connect((TARGET_HOST, TARGET_PORT))
+        log_info("System", "Connected to target: %s:%d" % (TARGET_HOST, TARGET_PORT))
+        
+        if method == "CONNECT":
+            # Send CONNECT response
+            response = b"HTTP/1.1 200 Connection Established\r\n\r\n"
+            b_socket.sendall(response)
+            log_info("System", "Sent CONNECT response")
+            
+            # Establish tunnel
+            def forward(src, dst):
                 try:
                     while True:
                         data = src.recv(8192)
                         if not data:
                             break
                         dst.sendall(data)
-    except Exception as e:
+                except:
                     pass
             
-def handle_b_device(sock):
+            t1 = threading.Thread(target=forward, args=(b_socket, target_sock))
-    """Handle communication with device B, establish tunnel to target website"""
+            t2 = threading.Thread(target=forward, args=(target_sock, b_socket))
-    print("\n[System] Connected to device B")
-    
-    try:
-        while True:
-            request = b""
-            while True:
-                chunk = sock.recv(8192)
-                if not chunk:
-                    print("[Device B] Disconnected")
-                    return
-                request += chunk
-                if b"\r\n\r\n" in request:
-                    break
-            
-            print("[System] Received request:", len(request), "bytes")
-            
-            target_host = None
-            target_port = 443
-            
-            if request.startswith(b"CONNECT"):
-                try:
-                    lines = request.decode().split("\r\n")
-                    connect_line = lines[0]
-                    target = connect_line.split()[1]
-                    if ':' in target:
-                        target_host, port_str = target.split(':')
-                        target_port = int(port_str)
-                    else:
-                        target_host = target
-                        target_port = 443
-                except Exception as e:
-                    print("[Error] Failed to parse CONNECT request:", e)
-                    sock.send(b"HTTP/1.1 400 Bad Request\r\n\r\n")
-                    continue
-            else:
-                try:
-                    for line in request.split(b"\r\n"):
-                        if line.lower().startswith(b"host:"):
-                            host_part = line[5:].strip()
-                            if b':' in host_part:
-                                target_host, port_str = host_part.split(b':')
-                                target_port = int(port_str)
-                            else:
-                                target_host = host_part.decode()
-                            break
-                except Exception as e:
-                    print("[Error] Failed to parse HTTP request:", e)
-                    sock.send(b"HTTP/1.1 400 Bad Request\r\n\r\n")
-                    continue
-            
-            if not target_host:
-                sock.send(b"HTTP/1.1 400 Bad Request\r\n\r\n")
-                continue
-            
-            print("[Target] Host:", target_host, "Port:", target_port)
-            
-            target_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-            target_sock.settimeout(30)
-            
-            try:
-                target_sock.connect((target_host, target_port))
-                print("[Target] Connected successfully")
-                
-                if request.startswith(b"CONNECT"):
-                    sock.send(b"HTTP/1.1 200 Connection Established\r\n\r\n")
-                else:
-                    target_sock.sendall(request)
-                
-                t1 = threading.Thread(target=tunnel_thread, args=(sock, target_sock))
-                t2 = threading.Thread(target=tunnel_thread, args=(target_sock, sock))
             t1.start()
             t2.start()
             t1.join()
             t2.join()
         
+        else:
+            # Forward request and response
+            target_sock.sendall(request_data)
+            
+            while True:
+                response = target_sock.recv(8192)
+                if not response:
+                    break
+                b_socket.sendall(response)
+        
+        return True
+    
     except ConnectionRefusedError:
-                print("[Error] Cannot connect to target:", target_host, target_port)
+        log_error("System", "Cannot connect to target: %s:%d" % (TARGET_HOST, TARGET_PORT))
-                error_msg = "HTTP/1.1 503 Service Unavailable\r\nContent-Type: text/plain\r\n\r\nCannot connect to " + target_host + ":" + str(target_port)
+        error_msg = b"HTTP/1.1 502 Bad Gateway\r\nContent-Type: text/plain\r\n\r\nCannot connect to target\r\n"
-                sock.send(error_msg.encode())
+        b_socket.sendall(error_msg)
+        return False
     except socket.timeout:
-                print("[Error] Connection timeout")
+        log_error("System", "Target connection timeout")
-                sock.send(b"HTTP/1.1 504 Gateway Timeout\r\n\r\n")
+        error_msg = b"HTTP/1.1 504 Gateway Timeout\r\nContent-Type: text/plain\r\n\r\nConnection timeout\r\n"
+        b_socket.sendall(error_msg)
+        return False
     except Exception as e:
-                print("[Error] Failed to connect to target:", e)
+        log_error("System", "Error handling request: %s" % str(e))
-                error_msg = "HTTP/1.1 500 Internal Server Error\r\nContent-Type: text/plain\r\n\r\n" + str(e)
+        return False
-                sock.send(error_msg.encode())
     finally:
         target_sock.close()
 
-    except ConnectionResetError:
+def listen_for_requests(sock):
-        print("[Device B] Connection forcibly closed")
+    """Listen for requests from device B"""
+    try:
+        while True:
+            # Wait for request with long timeout
+            sock.settimeout(600)  # 10 minutes
+            
+            request_data = b""
+            while b"\r\n\r\n" not in request_data:
+                chunk = sock.recv(8192)
+                if not chunk:
+                    log_info("System", "Device B disconnected")
+                    return
+                request_data += chunk
+            
+            # Handle request in a separate thread
+            t = threading.Thread(target=handle_request, args=(sock, request_data))
+            t.start()
+            
+    except socket.timeout:
+        log_info("System", "Connection idle timeout")
     except Exception as e:
-        print("[Error] Communication error with device B:", e)
+        log_error("System", "Connection error: %s" % str(e))
-    finally:
-        sock.close()
 
 def connect_to_b_device(b_host, b_port):
-    """Connect to device B"""
+    """Connect to device B and handle requests"""
     while True:
         try:
             sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
             sock.settimeout(10)
             sock.connect((b_host, b_port))
-            sock.settimeout(None)
             
-            print("\n[System] Successfully connected to device B:", b_host, ":", b_port)
+            # Wait for connection confirmation from server
+            sock.settimeout(5)
+            response = sock.recv(1024)
+            if not response or b"PROXY_CONNECTED" not in response:
+                log_error("System", "Failed to receive connection confirmation")
+                sock.close()
+                time.sleep(3)
+                continue
             
-            handle_b_device(sock)
+            log_info("System", "Successfully connected to device B: %s:%d" % (b_host, b_port))
+            
+            listen_for_requests(sock)
             
         except ConnectionRefusedError:
-            print("[System] Device B not ready (", b_host, ":", b_port, "), retrying in 3 seconds...")
+            log_info("System", "Device B not ready (%s:%d), retrying in 3 seconds..." % (b_host, b_port))
-            import time
             time.sleep(3)
         except socket.timeout:
-            print("[System] Connection timeout, retrying in 3 seconds...")
+            log_info("System", "Connection timeout, retrying in 3 seconds...")
-            import time
             time.sleep(3)
         except Exception as e:
-            print("[Error] Connection error:", e)
+            log_error("System", "Connection error: %s" % str(e))
-            import time
             time.sleep(3)
 
 def main():
@@ -143,6 +149,7 @@ def main():
         print("=" * 60)
         print("           Proxy Client (Run on Computer A)")
         print("=" * 60)
+        print("Target website:", TARGET_HOST, ":", TARGET_PORT)
         print("Usage: python proxy_client.py <Device B IP> <Device B Port>")
         print("Example: python proxy_client.py 192.168.1.100 8080")
         print("=" * 60)
@@ -154,6 +161,7 @@ def main():
     print("=" * 60)
     print("           Proxy Client (Run on Computer A)")
     print("=" * 60)
+    print("Target website:", TARGET_HOST, ":", TARGET_PORT)
     print("Device B address:", b_host, ":", b_port)
     print("=" * 60)
     

proxy/proxy_server.py

@@ -1,79 +1,173 @@
 # -*- coding: utf-8 -*-
 import socket
 import threading
-import sys
+import time
 
 PORT_FOR_A = 8080        # Port for device A to connect
 PORT_FOR_BROWSER = 8081  # Port for browser to connect
 
-a_device_socket = None
+a_device_conn = None
 a_device_lock = threading.Lock()
+a_device_connected = threading.Event()
 
-def tunnel_thread(src, dst):
+def log_info(source, message):
-    """Tunnel thread: continuously forward data"""
+    """Log info message"""
+    timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
+    print("[%s] [INFO] [%s] %s" % (timestamp, source, message))
+
+def log_error(source, message):
+    """Log error message"""
+    timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
+    print("[%s] [ERROR] [%s] %s" % (timestamp, source, message))
+
+def handle_browser(browser_conn, browser_addr):
+    """Handle browser connection"""
+    global a_device_conn
+    
+    log_info("Browser", "Connected from: %s:%d" % browser_addr)
+    
+    # Wait for device A to connect
+    if not a_device_connected.wait(timeout=5):
+        error_msg = b"HTTP/1.1 503 Service Unavailable\r\nContent-Type: text/plain\r\n\r\nDevice A not connected\r\n"
+        browser_conn.send(error_msg)
+        browser_conn.close()
+        log_info("Browser", "Disconnected (A not connected): %s:%d" % browser_addr)
+        return
+    
+    # Read HTTP request
+    request_start = time.time()
+    request_data = b""
+    browser_conn.settimeout(30)
+    
+    try:
+        while b"\r\n\r\n" not in request_data:
+            chunk = browser_conn.recv(8192)
+            if not chunk:
+                browser_conn.close()
+                log_info("Browser", "Disconnected (no request): %s:%d" % browser_addr)
+                return
+            request_data += chunk
+    except socket.timeout:
+        browser_conn.close()
+        log_info("Browser", "Disconnected (timeout): %s:%d" % browser_addr)
+        return
+    
+    # Parse HTTP request
+    request_lines = request_data.split(b"\r\n")
+    method = ""
+    url = ""
+    if request_lines:
+        first_line = request_lines[0].decode('utf-8', errors='ignore')
+        parts = first_line.split()
+        if len(parts) >= 2:
+            method = parts[0]
+            url = parts[1]
+            body_size = len(request_data)
+            log_info("Browser", "%s:%d - %s %s - Body: %d bytes" % (browser_addr[0], browser_addr[1], method, url, body_size))
+    
+    # Get device A connection
+    with a_device_lock:
+        device_a = a_device_conn
+    
+    if not device_a:
+        browser_conn.close()
+        log_error("Browser", "Disconnected (A closed): %s:%d" % browser_addr)
+        return
+    
+    # Send request to device A
+    device_a.sendall(request_data)
+    
+    # Wait for response
+    response_data = b""
+    device_a.settimeout(30)
+    
+    try:
+        while True:
+            chunk = device_a.recv(8192)
+            if not chunk:
+                break
+            response_data += chunk
+            if b"\r\n\r\n" in response_data:
+                if method == "CONNECT" and b"200 Connection Established" in response_data:
+                    break
+                if len(response_data) > 8192:
+                    break
+    except:
+        pass
+    
+    # Parse response status
+    response_status = "Unknown"
+    if response_data:
+        response_lines = response_data.split(b"\r\n")
+        if response_lines:
+            status_line = response_lines[0].decode('utf-8', errors='ignore')
+            status_parts = status_line.split()
+            if len(status_parts) >= 2:
+                response_status = status_parts[1]
+    
+    # Send response to browser
+    browser_conn.sendall(response_data)
+    
+    # Calculate response time
+    response_time = int((time.time() - request_start) * 1000)
+    log_info("Browser", "%s:%d - %s %s - Status: %s - Time: %dms" % (browser_addr[0], browser_addr[1], method, url, response_status, response_time))
+    
+    # For CONNECT, establish tunnel
+    if method == "CONNECT" and response_status == "200":
+        log_info("System", "Tunnel established between browser and Device A")
+        
+        def forward(src, dst):
             try:
                 while True:
                     data = src.recv(8192)
                     if not data:
                         break
                     dst.sendall(data)
-    except Exception as e:
-        pass
-    finally:
-        try:
-            src.close()
-        except:
-            pass
-        try:
-            dst.close()
             except:
                 pass
         
-def handle_browser(conn, addr):
+        t1 = threading.Thread(target=forward, args=(browser_conn, device_a))
-    """Handle browser connection, establish tunnel with device A"""
+        t2 = threading.Thread(target=forward, args=(device_a, browser_conn))
-    global a_device_socket
-    
-    print("\n[Browser] Connected from:", addr)
-    
-    with a_device_lock:
-        if not a_device_socket:
-            conn.send(b"HTTP/1.1 503 Service Unavailable\r\nContent-Type: text/plain\r\n\r\nDevice A not connected")
-            conn.close()
-            print("[Browser] Disconnected (Device A not connected):", addr)
-            return
-    
-    t1 = threading.Thread(target=tunnel_thread, args=(conn, a_device_socket))
-    t2 = threading.Thread(target=tunnel_thread, args=(a_device_socket, conn))
         t1.start()
         t2.start()
+        t1.join()
+        t2.join()
     
-    print("[System] Tunnel established between browser and device A")
+    browser_conn.close()
+    log_info("Browser", "Disconnected: %s:%d" % browser_addr)
 
-def handle_a_device(conn):
+def handle_a_device(conn, addr):
-    """Handle device A connection"""
+    """Handle device A connection - just store and hold"""
-    global a_device_socket
+    global a_device_conn
     
     with a_device_lock:
-        if a_device_socket:
+        if a_device_conn:
-            conn.send(b"ERROR: Another A device is already connected")
+            conn.send(b"ERROR: Another A device is already connected\r\n")
             conn.close()
+            log_info("DeviceA", "Rejected connection from %s:%d" % addr)
             return
-        a_device_socket = conn
         
-    print("\n[Device A] Connected:", conn.getpeername())
+        a_device_conn = conn
     
+    # Send connection confirmation
+    conn.send(b"PROXY_CONNECTED\r\n")
+    a_device_connected.set()
+    log_info("DeviceA", "Connected: %s:%d" % addr)
+    
+    # Keep connection open by waiting on an event (never triggered)
+    # Connection will be closed when browser tunnel ends or error occurs
     try:
-        while True:
+        event = threading.Event()
-            data = conn.recv(1)
+        event.wait()
-            if not data:
-                break
     except:
         pass
     finally:
         with a_device_lock:
-            a_device_socket = None
+            if a_device_conn == conn:
+                a_device_conn = None
+                a_device_connected.clear()
         conn.close()
-        print("[Device A] Disconnected")
+        log_info("DeviceA", "Disconnected")
 
 def run_browser_server():
     """Start browser listening port"""
@@ -82,7 +176,7 @@ def run_browser_server():
     server.bind(('0.0.0.0', PORT_FOR_BROWSER))
     server.listen(10)
     
-    print("[System] Browser proxy port started, listening on 0.0.0.0:", PORT_FOR_BROWSER)
+    log_info("System", "Browser port started on %d" % PORT_FOR_BROWSER)
     
     while True:
         conn, addr = server.accept()
@@ -96,19 +190,19 @@ def run_a_device_server():
     server.bind(('0.0.0.0', PORT_FOR_A))
     server.listen(1)
     
-    print("[System] Device A port started, listening on 0.0.0.0:", PORT_FOR_A)
+    log_info("System", "Device A port started on %d" % PORT_FOR_A)
     
     while True:
         conn, addr = server.accept()
-        t = threading.Thread(target=handle_a_device, args=(conn,))
+        t = threading.Thread(target=handle_a_device, args=(conn, addr))
         t.start()
 
 def main():
     print("=" * 60)
     print("           Proxy Server (Run on Computer B)")
     print("=" * 60)
-    print("Device A connection port:", PORT_FOR_A)
+    print("Device A port:", PORT_FOR_A)
-    print("Browser access port:", PORT_FOR_BROWSER)
+    print("Browser port:", PORT_FOR_BROWSER)
     print("=" * 60)
     print("Waiting for connections...\n")