Python中如何实现支持HTTP隧道的代理

要实现支持HTTP隧道的代理，核心是处理CONNECT请求并建立双向数据转发。下面是一个完整的实现示例：

import socket
import threading
import ssl
import select

class HTTPTunnelProxy:
    def __init__(self, host='0.0.0.0', port=8888):
        self.host = host
        self.port = port
        self.server_socket = None
        
    def start(self):
        """启动代理服务器"""
        self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        self.server_socket.bind((self.host, self.port))
        self.server_socket.listen(5)
        print(f"代理服务器启动在 {self.host}:{self.port}")
        
        while True:
            client_socket, client_addr = self.server_socket.accept()
            print(f"新连接来自: {client_addr}")
            thread = threading.Thread(target=self.handle_client, args=(client_socket,))
            thread.daemon = True
            thread.start()
    
    def handle_client(self, client_socket):
        """处理客户端连接"""
        try:
            # 读取客户端请求
            request = client_socket.recv(4096).decode('utf-8')
            
            if not request:
                return
                
            # 解析请求行
            first_line = request.split('\n')[0]
            method, url, version = first_line.split()
            
            if method.upper() == 'CONNECT':
                # 处理HTTP隧道请求
                self.handle_connect(client_socket, url, request)
            else:
                # 处理普通HTTP请求
                self.handle_http(client_socket, request)
                
        except Exception as e:
            print(f"处理客户端时出错: {e}")
        finally:
            client_socket.close()
    
    def handle_connect(self, client_socket, url, request):
        """处理CONNECT请求，建立隧道"""
        try:
            # 解析目标主机和端口
            host, port = url.split(':')
            port = int(port)
            
            # 连接到目标服务器
            remote_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            remote_socket.connect((host, port))
            
            # 发送200 Connection Established响应
            response = "HTTP/1.1 200 Connection Established\r\n\r\n"
            client_socket.send(response.encode())
            
            # 建立双向数据转发
            self.forward_data(client_socket, remote_socket)
            
        except Exception as e:
            print(f"建立隧道失败: {e}")
            error_response = "HTTP/1.1 502 Bad Gateway\r\n\r\n"
            client_socket.send(error_response.encode())
    
    def handle_http(self, client_socket, request):
        """处理普通HTTP请求"""
        try:
            # 解析目标主机
            lines = request.split('\n')
            host_line = [line for line in lines if line.lower().startswith('host:')]
            
            if not host_line:
                return
                
            host = host_line[0].split(':')[1].strip()
            port = 80
            
            # 连接到目标服务器
            remote_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            remote_socket.connect((host, port))
            
            # 转发请求
            remote_socket.send(request.encode())
            
            # 转发响应
            self.forward_data(client_socket, remote_socket)
            
        except Exception as e:
            print(f"处理HTTP请求失败: {e}")
    
    def forward_data(self, socket1, socket2):
        """在两个socket之间转发数据"""
        sockets = [socket1, socket2]
        
        while True:
            readable, _, exceptional = select.select(sockets, [], sockets, 1)
            
            if exceptional:
                break
                
            for sock in readable:
                try:
                    data = sock.recv(4096)
                    if not data:
                        return
                    
                    # 确定目标socket
                    target = socket2 if sock is socket1 else socket1
                    target.send(data)
                except:
                    return

def main():
    proxy = HTTPTunnelProxy()
    proxy.start()

if __name__ == "__main__":
    main()

这个实现的关键点：

1. CONNECT请求处理：当收到CONNECT请求时，解析目标地址（如CONNECT example.com:443 HTTP/1.1），建立到目标服务器的TCP连接。

2. 隧道建立：连接成功后，向客户端发送200 Connection Established响应，然后开始双向数据转发。

3. 数据转发：使用select模块监控两个socket，当任一方向有数据时立即转发到另一个socket。

4. 线程处理：每个客户端连接使用独立线程，避免阻塞。

使用示例：

# 启动代理
python proxy.py

# 客户端使用（以curl为例）
curl --proxy http://localhost:8888 https://example.com

对于HTTPS隧道，客户端会先发送CONNECT请求建立隧道，然后通过该隧道进行SSL/TLS握手和加密通信。这个实现支持基本的HTTP代理功能，包括HTTP和HTTPS（通过隧道）。

总结：核心是正确处理CONNECT方法和建立双向数据通道。