| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195 |
- import socket
- import threading
- import select
- import base64
- import time
- class ProxyTunnel:
- """
- Local proxy tunnel manager
- 1. Enables TCP_NODELAY to eliminate handshake latency.
- 2. Enables KeepAlive to prevent idle disconnection.
- 3. Uses blocking sendall with select polling to prevent data loss.
- """
- def __init__(self, upstream_ip, upstream_port, username, password):
- self.upstream_ip = upstream_ip
- self.upstream_port = int(upstream_port)
- self.username = username
- self.password = password
-
- # Pre-compute Proxy-Authorization header
- auth_str = f"{username}:{password}"
- b64_auth = base64.b64encode(auth_str.encode()).decode()
- self.auth_header = f"Proxy-Authorization: Basic {b64_auth}\r\n"
-
- self.server_socket = None
- self.local_port = 0
- self.running = False
- self.listen_thread = None
- def start(self):
- try:
- 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(('127.0.0.1', 0))
- self.local_port = self.server_socket.getsockname()[1]
- self.server_socket.listen(128) # Increase listen backlog
-
- self.running = True
-
- self.listen_thread = threading.Thread(target=self._accept_loop, daemon=True)
- self.listen_thread.start()
-
- return f"127.0.0.1:{self.local_port}"
- except Exception as e:
- self.stop()
- raise RuntimeError(f"Failed to start tunnel: {e}")
- def stop(self):
- self.running = False
- if self.server_socket:
- try:
- self.server_socket.close()
- except Exception:
- pass
- self.server_socket = None
- def _accept_loop(self):
- while self.running:
- try:
- if self.server_socket:
- # Use select instead of settimeout to reduce CPU idle spinning
- r, _, _ = select.select([self.server_socket], [], [], 1.0)
- if r:
- try:
- client_sock, _ = self.server_socket.accept()
- t = threading.Thread(target=self._handle_client, args=(client_sock,), daemon=True)
- t.start()
- except OSError:
- break
- except Exception:
- continue
- def _optimize_socket(self, sock):
- """Socket options optimization"""
- try:
- # 1. Disable Nagle's algorithm: packets sent immediately without buffer delay
- # Crucial for preventing HttpClient timeouts
- sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
-
- # 2. Enable KeepAlive: prevent firewalls from terminating idle connections
- sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
-
- # 3. Increase buffer sizes
- sock.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 32*1024)
- sock.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 32*1024)
- except Exception:
- pass
- def _handle_client(self, client_sock):
- upstream_sock = None
- try:
- self._optimize_socket(client_sock)
- client_sock.settimeout(30)
-
- # 1. Read first packet (32KB buffer)
- try:
- first_packet = client_sock.recv(32768)
- except socket.timeout:
- return # Client connected without sending data
-
- if not first_packet:
- return
- # 2. Connect to upstream
- upstream_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
- self._optimize_socket(upstream_sock) # Optimize upstream socket
-
- upstream_sock.settimeout(10) # Connect timeout: 10s
- upstream_sock.connect((self.upstream_ip, self.upstream_port))
-
- # Switch to blocking mode once connected; multiplexing handled by select
- upstream_sock.settimeout(None)
- client_sock.settimeout(None)
-
- # 3. Inject Header
- sep = b'\r\n'
- idx = first_packet.find(sep)
- if idx != -1:
- new_packet = first_packet[:idx+2] + self.auth_header.encode() + first_packet[idx+2:]
- else:
- new_packet = first_packet
- # 4. Send first packet (blocking sendall to guarantee integrity)
- upstream_sock.sendall(new_packet)
-
- # 5. Bi-directional proxy forwarding
- self._pipe_sockets(client_sock, upstream_sock)
- except Exception:
- pass
- finally:
- self._close_socket(client_sock)
- self._close_socket(upstream_sock)
- def _pipe_sockets(self, sock1, sock2):
- """
- Forwarding logic:
- Maintains blocking socket mode while using select to poll readable state.
- """
- sockets = [sock1, sock2]
- last_activity = time.time()
- IDLE_TIMEOUT = 120 # Extended idle timeout
-
- while self.running:
- try:
- # Listen for readable sockets
- r, _, x = select.select(sockets, [], sockets, 1.0)
-
- if x: break # Socket exception
-
- if not r:
- if time.time() - last_activity > IDLE_TIMEOUT:
- break
- continue
-
- for s in r:
- try:
- # Attempt read
- data = s.recv(32768)
- except ConnectionResetError:
- data = None
-
- if not data:
- return # Connection closed
-
- # Determine forwarding destination
- target = sock2 if s is sock1 else sock1
-
- # Blocking sendall: pauses thread if network is congested without packet drops
- try:
- target.sendall(data)
- except BrokenPipeError:
- return
-
- last_activity = time.time()
-
- except Exception:
- break
- def _close_socket(self, sock):
- """Gracefully closes socket."""
- if sock:
- try:
- # Send FIN packet to signal completion
- sock.shutdown(socket.SHUT_RDWR)
- except Exception:
- pass
- try:
- sock.close()
- except Exception:
- pass
- def __del__(self):
- self.stop()
|