Python代理服务器处理CONNECT请求无响应的实现咨询

你遇到的问题核心是对CONNECT请求的处理逻辑理解偏差了——CONNECT请求的作用是让代理帮客户端建立一条TCP隧道，而非像普通HTTP请求那样转发请求头并等待服务器返回HTTP响应。咱们一步步拆解问题和解决方案：

为什么你的现有代码无法工作？ #

看你的请求头，客户端发的是CONNECT www.google.com:443 HTTP/1.1，这意味着客户端希望代理和www.google.com:443建立TCP连接，之后客户端会直接通过这个隧道发送TLS握手数据（HTTPS的加密流量）。

但你的代码做了两件错误的事：

• 把完整的CONNECT请求头发送给了目标服务器：目标服务器收到CONNECT请求后，并不会返回HTTP响应（除非有代理认证场景），它会直接保持连接等待数据，所以你client_socket.recv(1024)得到空数据是正常的——因为服务器没发HTTP响应，在等TLS握手呢。
• 没有处理双向数据转发：隧道建立后，客户端和服务器需要通过代理互相传输数据，单线程的recv/send根本无法同时处理双向流量。

正确的CONNECT请求处理流程 #

处理CONNECT请求只需要这几步：

1. 解析CONNECT请求中的目标主机和端口（从请求行或Host头提取）
2. 代理与目标服务器建立TCP连接
3. 代理向客户端返回HTTP/1.1 200 Connection Established\r\n\r\n，告知客户端隧道已就绪
4. 启动双向数据转发：同时监听客户端socket和目标服务器socket，把一端的数据转发到另一端，直到任意一端关闭连接

修正后的代码示例 #

因为要处理双向转发，我们需要用线程来实现，避免阻塞。下面是修正后的简化版代码：

import socket
import threading

IP = "0.0.0.0"
PORT = 1234

def forward_data(source, destination):
    """双向转发数据的工具函数"""
    try:
        while True:
            data = source.recv(4096)
            if not data:
                break
            destination.sendall(data)
    except Exception as e:
        pass
    finally:
        source.close()
        destination.close()

def handle_client(conn):
    try:
        # 读取完整的请求头部
        request = b""
        while b"\r\n\r\n" not in request:
            chunk = conn.recv(1024)
            if not chunk:
                return
            request += chunk
        
        # 判断是否是CONNECT请求
        request_line = request.split(b"\r\n")[0]
        if request_line.startswith(b"CONNECT"):
            # 解析目标地址：CONNECT www.google.com:443 HTTP/1.1
            _, target, _ = request_line.split(b" ", 2)
            if b":" not in target:
                target += b":443"  # 默认HTTPS端口
            addr, port = target.split(b":")
            addr = addr.decode("utf-8").strip()
            port = int(port.decode("utf-8").strip())
            
            # 连接目标服务器
            client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            try:
                client_socket.connect((addr, port))
                # 向客户端返回隧道建立成功的响应
                conn.sendall(b"HTTP/1.1 200 Connection Established\r\n\r\n")
                
                # 启动双向转发线程
                threading.Thread(target=forward_data, args=(conn, client_socket)).start()
                threading.Thread(target=forward_data, args=(client_socket, conn)).start()
            except Exception as e:
                conn.sendall(b"HTTP/1.1 503 Service Unavailable\r\n\r\n")
                client_socket.close()
                conn.close()
        else:
            # 处理普通HTTP请求（保留你的原有逻辑）
            header_bytes = request
            print("header: ", header_bytes)
            # 提取Host头
            target_addr = None
            for header in header_bytes.split(b"\r\n"):
                if b":" in header:
                    key, value = header.split(b":", 1)
                    if key == b"Host":
                        if b":" not in value:
                            value += b":80"
                        target_addr = value.strip()
                        break
            if target_addr:
                addr, port = target_addr.split(b":")
                addr = addr.decode("utf-8")
                port = int(port.decode("utf-8"))
                client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                try:
                    client_socket.connect((addr, port))
                    client_socket.sendall(header_bytes)
                    # 循环转发响应直到完成
                    while True:
                        response = client_socket.recv(4096)
                        if not response:
                            break
                        conn.sendall(response)
                except Exception as e:
                    conn.sendall(b"HTTP/1.1 503 Service Unavailable\r\n\r\n")
                finally:
                    client_socket.close()
                    conn.close()
    except Exception as e:
        conn.close()

def main():
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
    server_socket.bind((IP, PORT))
    server_socket.listen(5)
    print(f"Proxy listening on {IP}:{PORT}")
    while True:
        conn, addr = server_socket.accept()
        print(f"Accepted connection from {addr}")
        threading.Thread(target=handle_client, args=(conn,)).start()

if __name__ == "__main__":
    main()

关键说明 #

• 双向转发：用两个线程分别处理客户端到服务器、服务器到客户端的数据传输，避免因等待某一端数据而阻塞整个流程。
• CONNECT响应：只需要返回200 Connection Established即可，不需要转发请求头给目标服务器——隧道建立后，客户端和服务器直接通信，代理仅做数据中转。
• 错误处理：添加了基本异常捕获，比如连接目标服务器失败时返回503错误给客户端。

内容的提问来源于stack exchange，提问作者Martin Gustafsson