Fix Xray reverse access and compatible router core installation

This commit is contained in:
kzolotarev95 committed 2026-10-29 13:06:54 +04:00
1 parent 5956daa8c2
commit d7d350fd8b
14 files changed
+1135 -32

No files matched your search

+154
View File
@@ -0,0 +1,154 @@
"""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):
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])
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'])
result = harness.run_shell('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)
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)
if __name__ == '__main__':
unittest.main()