proxy_tunnel.py 6.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195
  1. import socket
  2. import threading
  3. import select
  4. import base64
  5. import time
  6. class ProxyTunnel:
  7. """
  8. Local proxy tunnel manager
  9. 1. Enables TCP_NODELAY to eliminate handshake latency.
  10. 2. Enables KeepAlive to prevent idle disconnection.
  11. 3. Uses blocking sendall with select polling to prevent data loss.
  12. """
  13. def __init__(self, upstream_ip, upstream_port, username, password):
  14. self.upstream_ip = upstream_ip
  15. self.upstream_port = int(upstream_port)
  16. self.username = username
  17. self.password = password
  18. # Pre-compute Proxy-Authorization header
  19. auth_str = f"{username}:{password}"
  20. b64_auth = base64.b64encode(auth_str.encode()).decode()
  21. self.auth_header = f"Proxy-Authorization: Basic {b64_auth}\r\n"
  22. self.server_socket = None
  23. self.local_port = 0
  24. self.running = False
  25. self.listen_thread = None
  26. def start(self):
  27. try:
  28. self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  29. self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
  30. self.server_socket.bind(('127.0.0.1', 0))
  31. self.local_port = self.server_socket.getsockname()[1]
  32. self.server_socket.listen(128) # Increase listen backlog
  33. self.running = True
  34. self.listen_thread = threading.Thread(target=self._accept_loop, daemon=True)
  35. self.listen_thread.start()
  36. return f"127.0.0.1:{self.local_port}"
  37. except Exception as e:
  38. self.stop()
  39. raise RuntimeError(f"Failed to start tunnel: {e}")
  40. def stop(self):
  41. self.running = False
  42. if self.server_socket:
  43. try:
  44. self.server_socket.close()
  45. except Exception:
  46. pass
  47. self.server_socket = None
  48. def _accept_loop(self):
  49. while self.running:
  50. try:
  51. if self.server_socket:
  52. # Use select instead of settimeout to reduce CPU idle spinning
  53. r, _, _ = select.select([self.server_socket], [], [], 1.0)
  54. if r:
  55. try:
  56. client_sock, _ = self.server_socket.accept()
  57. t = threading.Thread(target=self._handle_client, args=(client_sock,), daemon=True)
  58. t.start()
  59. except OSError:
  60. break
  61. except Exception:
  62. continue
  63. def _optimize_socket(self, sock):
  64. """Socket options optimization"""
  65. try:
  66. # 1. Disable Nagle's algorithm: packets sent immediately without buffer delay
  67. # Crucial for preventing HttpClient timeouts
  68. sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
  69. # 2. Enable KeepAlive: prevent firewalls from terminating idle connections
  70. sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
  71. # 3. Increase buffer sizes
  72. sock.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 32*1024)
  73. sock.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 32*1024)
  74. except Exception:
  75. pass
  76. def _handle_client(self, client_sock):
  77. upstream_sock = None
  78. try:
  79. self._optimize_socket(client_sock)
  80. client_sock.settimeout(30)
  81. # 1. Read first packet (32KB buffer)
  82. try:
  83. first_packet = client_sock.recv(32768)
  84. except socket.timeout:
  85. return # Client connected without sending data
  86. if not first_packet:
  87. return
  88. # 2. Connect to upstream
  89. upstream_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  90. self._optimize_socket(upstream_sock) # Optimize upstream socket
  91. upstream_sock.settimeout(10) # Connect timeout: 10s
  92. upstream_sock.connect((self.upstream_ip, self.upstream_port))
  93. # Switch to blocking mode once connected; multiplexing handled by select
  94. upstream_sock.settimeout(None)
  95. client_sock.settimeout(None)
  96. # 3. Inject Header
  97. sep = b'\r\n'
  98. idx = first_packet.find(sep)
  99. if idx != -1:
  100. new_packet = first_packet[:idx+2] + self.auth_header.encode() + first_packet[idx+2:]
  101. else:
  102. new_packet = first_packet
  103. # 4. Send first packet (blocking sendall to guarantee integrity)
  104. upstream_sock.sendall(new_packet)
  105. # 5. Bi-directional proxy forwarding
  106. self._pipe_sockets(client_sock, upstream_sock)
  107. except Exception:
  108. pass
  109. finally:
  110. self._close_socket(client_sock)
  111. self._close_socket(upstream_sock)
  112. def _pipe_sockets(self, sock1, sock2):
  113. """
  114. Forwarding logic:
  115. Maintains blocking socket mode while using select to poll readable state.
  116. """
  117. sockets = [sock1, sock2]
  118. last_activity = time.time()
  119. IDLE_TIMEOUT = 120 # Extended idle timeout
  120. while self.running:
  121. try:
  122. # Listen for readable sockets
  123. r, _, x = select.select(sockets, [], sockets, 1.0)
  124. if x: break # Socket exception
  125. if not r:
  126. if time.time() - last_activity > IDLE_TIMEOUT:
  127. break
  128. continue
  129. for s in r:
  130. try:
  131. # Attempt read
  132. data = s.recv(32768)
  133. except ConnectionResetError:
  134. data = None
  135. if not data:
  136. return # Connection closed
  137. # Determine forwarding destination
  138. target = sock2 if s is sock1 else sock1
  139. # Blocking sendall: pauses thread if network is congested without packet drops
  140. try:
  141. target.sendall(data)
  142. except BrokenPipeError:
  143. return
  144. last_activity = time.time()
  145. except Exception:
  146. break
  147. def _close_socket(self, sock):
  148. """Gracefully closes socket."""
  149. if sock:
  150. try:
  151. # Send FIN packet to signal completion
  152. sock.shutdown(socket.SHUT_RDWR)
  153. except Exception:
  154. pass
  155. try:
  156. sock.close()
  157. except Exception:
  158. pass
  159. def __del__(self):
  160. self.stop()