OpenWrt IPK and APK / Validate source and resolve stable SDKs (push) Waiting to run
189 lines
9.0 KiB
Python
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()
|