Files
luci-app-owrt-remote/tests/test_xray_reverse_transport.py
kzolotarev95 70a4705e67
OpenWrt IPK and APK / Validate source and resolve stable SDKs (push) Waiting to run
Release v122 with Tachyon integration and resilient Xray downloads
2026-11-21 22:53:52 +04:00

189 lines
9.0 KiB
Python

"""Exercise both generated reverse channels with real Xray processes on loopback."""
import http.client
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
import json
import os
from pathlib import Path
import socket
import socketserver
import subprocess
import tempfile
import threading
import time
import unittest
import uuid
import test_host_policy as shell_tests
hub, SH = shell_tests.hub, shell_tests.SH
class HTTPProbe(BaseHTTPRequestHandler):
def do_GET(self):
body = b'OWRT_HTTP_REVERSE_OK'
self.send_response(200)
self.send_header('Content-Length', str(len(body)))
self.end_headers()
self.wfile.write(body)
def log_message(self, *args):
pass
class SSHProbe(socketserver.BaseRequestHandler):
def handle(self):
self.request.sendall(b'SSH-2.0-OWRT_TEST\r\n')
self.request.settimeout(2)
try:
self.request.recv(128)
except OSError:
pass
def free_port():
with socket.socket() as sock:
sock.bind(('127.0.0.1', 0))
return sock.getsockname()[1]
@unittest.skipUnless(os.environ.get('OWRT_TEST_XRAY_BIN'), 'Set a real compatible Xray binary')
class ReverseTransportTests(unittest.TestCase):
def setUp(self):
self.temp = tempfile.TemporaryDirectory(prefix='owrt-reverse-')
self.addCleanup(self.temp.cleanup)
self.root = Path(self.temp.name)
self.http_server = ThreadingHTTPServer(('127.0.0.1', 0), HTTPProbe)
self.ssh_server = socketserver.ThreadingTCPServer(('127.0.0.1', 0), SSHProbe)
self.ssh_server.daemon_threads = True
for server in (self.http_server, self.ssh_server):
thread = threading.Thread(target=server.serve_forever, daemon=True)
thread.start()
self.addCleanup(self.close_server, server, thread)
self.client_bin = Path(os.environ['OWRT_TEST_XRAY_BIN']).resolve()
@staticmethod
def close_server(server, thread):
server.shutdown()
server.server_close()
thread.join(timeout=3)
def check_pair(self, server_bin, shell_client=False, tachyon=False):
processes, streams = [], []
row = dict(id='probe', name='probe', entry_port=free_port(), ssh_entry_port=free_port(),
vps_host='127.0.0.1', vless_port=free_port(), vless_uuid=str(uuid.uuid4()),
ssh_vless_uuid=str(uuid.uuid4()), vless_encryption='none', vless_flow='',
reverse_tag='reverse-in', ssh_reverse_tag='reverse-in-ssh',
admin_host='127.0.0.1', admin_port=self.http_server.server_port,
ssh_host='127.0.0.1', ssh_port=self.ssh_server.server_address[1])
if tachyon:
class TachyonProbe(HTTPProbe):
def do_GET(self):
data = b'TACHYON_SELECTED_ROUTER_OK'
self.send_response(200); self.send_header('Content-Length', str(len(data)))
self.end_headers(); self.wfile.write(data)
service = ThreadingHTTPServer(('127.0.0.1', 0), TachyonProbe)
thread = threading.Thread(target=service.serve_forever, daemon=True); thread.start()
self.addCleanup(self.close_server, service, thread)
row['tachyon_entry_port'] = free_port()
row['status_json'] = json.dumps({'tachyon': {'checked': True, 'installed': True,
'mode': 'standalone', 'port': service.server_port, 'available': True}})
configs = dict(server=hub.make_server_xray_config([row], listen_host='127.0.0.1',
listen_port=row['vless_port']),
client=hub.make_router_xray_config(row))
if shell_client:
harness = shell_tests.RouterShellTests()
harness.setUp()
try:
harness.config(vps_host=row['vps_host'], vps_port=row['vless_port'],
vless_uuid=row['vless_uuid'], ssh_vless_uuid=row['ssh_vless_uuid'],
reverse_tag=row['reverse_tag'], ssh_reverse_tag=row['ssh_reverse_tag'],
admin_host=row['admin_host'], admin_port=row['admin_port'],
ssh_host=row['ssh_host'], ssh_port=row['ssh_port'])
injection = ('tachyon_tunnel_port() { printf ' + str(service.server_port) + '; }\n') if tachyon else ''
result = harness.run_shell(injection + 'render_client_config --stdout')
self.assertEqual(result.returncode, 0, result.stderr)
configs['client'] = json.loads(result.stdout)
finally:
harness.doCleanups()
try:
for name, config in configs.items():
config['log'] = {'loglevel': 'debug'}
path = self.root / (name + '.json')
path.write_text(json.dumps(config), encoding='utf-8')
binary = server_bin if name == 'server' else self.client_bin
check = subprocess.run([str(binary), '-test', '-config', str(path)],
capture_output=True, text=True, timeout=10)
self.assertEqual(check.returncode, 0, check.stdout + check.stderr)
stream = (self.root / (name + '.log')).open('wb')
streams.append(stream)
processes.append(subprocess.Popen([str(binary), 'run', '-config', str(path)],
stdout=stream, stderr=subprocess.STDOUT))
deadline = time.monotonic() + 18
response, error = None, ''
while time.monotonic() < deadline:
connection = http.client.HTTPConnection('127.0.0.1', row['entry_port'], timeout=1)
try:
connection.request('GET', '/')
with connection.getresponse() as result:
response = result.status, result.read()
break
except OSError as exc:
error = repr(exc)
finally:
connection.close()
if any(process.poll() is not None for process in processes):
break
time.sleep(.1)
logs = '\n'.join((self.root / (name + '.log')).read_text(encoding='utf-8', errors='replace')[-6000:]
for name in configs)
self.assertEqual(response, (200, b'OWRT_HTTP_REVERSE_OK'), error + '\n' + logs)
with socket.create_connection(('127.0.0.1', row['ssh_entry_port']), timeout=3) as sock:
sock.settimeout(3)
self.assertEqual(sock.recv(128), b'SSH-2.0-OWRT_TEST\r\n', logs)
if tachyon:
connection = http.client.HTTPConnection('127.0.0.1', row['tachyon_entry_port'], timeout=5)
try:
connection.request('GET', '/')
with connection.getresponse() as result:
self.assertEqual((result.status, result.read()), (200, b'TACHYON_SELECTED_ROUTER_OK'), logs)
finally:
connection.close()
finally:
for process in processes:
process.terminate()
try:
process.wait(timeout=3)
except subprocess.TimeoutExpired:
process.kill()
process.wait(timeout=3)
for stream in streams:
stream.close()
def test_compatible_router_with_same_server_version(self):
self.check_pair(self.client_bin)
@unittest.skipUnless(os.environ.get('OWRT_TEST_NEW_XRAY_BIN'), 'Set a modern server Xray binary')
def test_compatible_router_with_modern_server(self):
self.check_pair(Path(os.environ['OWRT_TEST_NEW_XRAY_BIN']).resolve())
@unittest.skipUnless(SH and os.environ.get('OWRT_TEST_NEW_XRAY_BIN'), 'POSIX shell and modern server required')
def test_real_router_shell_config_with_modern_server(self):
self.check_pair(Path(os.environ['OWRT_TEST_NEW_XRAY_BIN']).resolve(), shell_client=True)
@unittest.skipUnless(SH and os.environ.get('OWRT_TEST_NEW_XRAY_BIN'), 'POSIX shell and modern server required')
def test_tachyon_admin_and_ssh_share_reverse_without_cross_routing(self):
self.check_pair(Path(os.environ['OWRT_TEST_NEW_XRAY_BIN']).resolve(), shell_client=True, tachyon=True)
@unittest.skipUnless(SH and os.environ.get('OWRT_TEST_OLD_XRAY_BIN'), 'Legacy server Xray binary required')
def test_tachyon_with_26327_server_preserves_destination_port(self):
self.check_pair(Path(os.environ['OWRT_TEST_OLD_XRAY_BIN']).resolve(), shell_client=True, tachyon=True)
@unittest.skipUnless(SH and os.environ.get('OWRT_TEST_OLD_XRAY_BIN'), 'Legacy Xray binaries required')
def test_tachyon_with_26327_router_and_server(self):
self.client_bin = Path(os.environ['OWRT_TEST_OLD_XRAY_BIN']).resolve()
self.check_pair(self.client_bin, shell_client=True, tachyon=True)
if __name__ == '__main__':
unittest.main()