258 lines
13 KiB
Python
258 lines
13 KiB
Python
"""Candidate validation, atomic installation and the uclient proxy regression."""
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
import subprocess
|
|
import unittest
|
|
|
|
import test_host_policy as shell_tests
|
|
|
|
ROOT, SH = shell_tests.ROOT, shell_tests.SH
|
|
ADMIN_UUID = "11111111-1111-4111-8111-111111111111"
|
|
SSH_UUID = "22222222-2222-4222-8222-222222222222"
|
|
|
|
# BusyBox expand() without FEATURE_TR_CLASSES treats class notation as
|
|
# literal characters, unlike the GNU tr available on the test host.
|
|
CLASSLESS_TR = r'''
|
|
tr() {
|
|
if [ "$1" = -d ]; then
|
|
case "$2" in
|
|
'[:space:][:cntrl:]') command tr -d '[]:spacecntrl'; return ;;
|
|
'[:space:]') command tr -d '[]:space'; return ;;
|
|
esac
|
|
fi
|
|
command tr "$@"
|
|
}
|
|
'''
|
|
|
|
|
|
@unittest.skipUnless(SH, "POSIX shell required")
|
|
class XrayValidationTests(unittest.TestCase):
|
|
setUp = shell_tests.RouterShellTests.setUp
|
|
config = shell_tests.RouterShellTests.config
|
|
run_shell = shell_tests.RouterShellTests.run_shell
|
|
|
|
def prepare(self, **overrides):
|
|
self.target = self.directory / "current.json"
|
|
self.target.write_text('{"working":true}\n', encoding="utf-8")
|
|
binary = self.directory / "xray"
|
|
binary.write_text(r'''#!/bin/sh
|
|
[ "$1" = -test ] && [ "$2" = -config ] || exit 99
|
|
printf '%s\n' "$*" >>"$TEST_ROOT/xray-tests"
|
|
case "$3" in *.json) ;; *) echo 'Failed to get format' >&2; exit 1 ;; esac
|
|
cmp "$TEST_ROOT/current.json" "$TEST_ROOT/original.json" || exit 98
|
|
cp "$3" "$TEST_ROOT/tested.json"
|
|
if [ "${XRAY_FAIL:-0}" != 0 ]; then
|
|
printf '%s\n' 'Failed to start: VLESS users: "flow" does not support this value' >&2
|
|
exit "$XRAY_FAIL"
|
|
fi
|
|
printf 'Configuration OK.\n'
|
|
''', encoding="utf-8", newline="\n")
|
|
binary.chmod(0o755)
|
|
self.directory.joinpath("original.json").write_bytes(self.target.read_bytes())
|
|
values = dict(vps_host="hub.example", vps_port="8443", vless_uuid=ADMIN_UUID,
|
|
ssh_vless_uuid=SSH_UUID, reverse_tag="main:admin", ssh_reverse_tag="main:ssh",
|
|
xray_bin=binary.as_posix(), xray_config=self.target.as_posix())
|
|
values.update(overrides)
|
|
self.config(**values)
|
|
|
|
def assert_no_candidate(self):
|
|
self.assertFalse(list(self.directory.glob(".owrt-remote-client.*")))
|
|
|
|
def test_real_xray_error_preserves_previous_config_and_exit_code(self):
|
|
self.prepare(vless_flow="unsupported-flow")
|
|
result = self.run_shell("render_client_config", XRAY_FAIL="1")
|
|
self.assertEqual(result.returncode, 1, result.stderr)
|
|
self.assertEqual(result.stdout, "")
|
|
self.assertIn('VLESS users: "flow" does not support', result.stderr)
|
|
self.assertIn("Рабочий JSON не заменён", result.stderr)
|
|
self.assertEqual(self.target.read_bytes(), self.directory.joinpath("original.json").read_bytes())
|
|
self.assert_no_candidate()
|
|
|
|
def test_success_only_installs_exact_bytes_that_passed_xray(self):
|
|
self.prepare(vps_port="08443", admin_port="00080", ssh_port="00022")
|
|
result = self.run_shell("render_client_config")
|
|
self.assertEqual(result.returncode, 0, result.stderr)
|
|
self.assertEqual(result.stdout.strip(), self.target.as_posix())
|
|
self.assertIn("Configuration OK", result.stderr)
|
|
self.assertEqual(self.target.read_bytes(), self.directory.joinpath("tested.json").read_bytes())
|
|
config = json.loads(self.target.read_text())
|
|
self.assertEqual(config["outbounds"][2]["settings"]["port"], 8443)
|
|
self.assertEqual(config["outbounds"][0]["settings"]["redirect"], "127.0.0.1:80")
|
|
self.assertEqual(config["outbounds"][2]["settings"]["reverse"]["tag"], "main:admin")
|
|
self.assert_no_candidate()
|
|
if os.name != "nt":
|
|
self.assertEqual(self.target.stat().st_mode & 0o777, 0o600)
|
|
|
|
def test_invalid_uuid_port_and_conflicting_tags_cannot_replace_config(self):
|
|
bad_values = [
|
|
({"vless_uuid": "not-a-uuid"}, "vless_uuid"),
|
|
({"ssh_vless_uuid": "bad"}, "ssh_vless_uuid"),
|
|
({"ssh_vless_uuid": ADMIN_UUID}, "должны различаться"),
|
|
({"vps_port": "65536"}, "vps_port"),
|
|
({"admin_port": "abc"}, "admin_port"),
|
|
({"ssh_port": "0"}, "ssh_port"),
|
|
({"reverse_tag": "main admin"}, "reverse_tag"),
|
|
({"ssh_reverse_tag": "main:admin"}, "должны различаться"),
|
|
({"reverse_tag": "router-admin"}, "внутренней меткой"),
|
|
]
|
|
for values, message in bad_values:
|
|
with self.subTest(values=values):
|
|
self.prepare(**values)
|
|
result = self.run_shell("render_client_config")
|
|
self.assertNotEqual(result.returncode, 0)
|
|
self.assertIn(message, result.stderr)
|
|
self.assertEqual(self.target.read_bytes(), self.directory.joinpath("original.json").read_bytes())
|
|
self.assert_no_candidate()
|
|
|
|
def test_multiline_uuid_and_tag_are_rejected_without_silently_rewriting(self):
|
|
self.prepare()
|
|
result = self.run_shell('xray_valid_uuid "$TEST_VALUE"', TEST_VALUE=ADMIN_UUID + "\nextra")
|
|
self.assertNotEqual(result.returncode, 0)
|
|
result = self.run_shell('xray_valid_tag reverse_tag "$TEST_VALUE"', TEST_VALUE="main\nadmin")
|
|
self.assertNotEqual(result.returncode, 0)
|
|
self.assertIn("reverse_tag", result.stderr)
|
|
self.assertEqual(self.target.read_bytes(), self.directory.joinpath("original.json").read_bytes())
|
|
|
|
def test_openwrt_classless_tr_preserves_hub_tags_and_host(self):
|
|
self.prepare(reverse_tag="reverse-in", ssh_reverse_tag="reverse-in-ssh")
|
|
old_check = self.run_shell(CLASSLESS_TR + "printf '%s' reverse-in | tr -d '[:space:][:cntrl:]'")
|
|
self.assertEqual(old_check.stdout, "v-i", "The old validator falsely changed a valid tag")
|
|
result = self.run_shell(CLASSLESS_TR + "render_client_config")
|
|
self.assertEqual(result.returncode, 0, result.stderr)
|
|
config = json.loads(self.target.read_text())
|
|
self.assertEqual(config["outbounds"][2]["settings"]["reverse"]["tag"], "reverse-in")
|
|
self.assertEqual(config["outbounds"][3]["settings"]["reverse"]["tag"], "reverse-in-ssh")
|
|
self.assertEqual(config["outbounds"][2]["settings"]["address"], "hub.example")
|
|
self.assertEqual(self.target.read_bytes(), self.directory.joinpath("tested.json").read_bytes())
|
|
self.assert_no_candidate()
|
|
|
|
def test_openwrt_classless_tr_still_rejects_real_whitespace_and_controls(self):
|
|
self.prepare()
|
|
result = self.run_shell(CLASSLESS_TR + r'''
|
|
for octal in 001 011 012 015 037 040 177; do
|
|
control=$(printf "\\$octal."); control=${control%.}
|
|
if xray_valid_tag reverse_tag "reverse-in${control}"; then
|
|
echo "Accepted invalid control $octal" >&2; exit 99
|
|
fi
|
|
done
|
|
''')
|
|
self.assertEqual(result.returncode, 0, result.stderr)
|
|
for host in ("hub example", "hub\texample", "hub\x01example", "hub\x7fexample"):
|
|
with self.subTest(host=repr(host)):
|
|
self.prepare(vps_host=host)
|
|
result = self.run_shell(CLASSLESS_TR + "render_client_config")
|
|
self.assertNotEqual(result.returncode, 0)
|
|
self.assertIn("host содержит", result.stderr)
|
|
self.assertEqual(self.target.read_bytes(), self.directory.joinpath("original.json").read_bytes())
|
|
self.assert_no_candidate()
|
|
|
|
def test_missing_xray_cannot_replace_config(self):
|
|
self.prepare()
|
|
result = self.run_shell('ensure_xray_available() { echo "Xray unavailable" >&2; return 1; }; render_client_config')
|
|
self.assertNotEqual(result.returncode, 0)
|
|
self.assertIn("Xray unavailable", result.stderr)
|
|
self.assertEqual(self.target.read_bytes(), self.directory.joinpath("original.json").read_bytes())
|
|
self.assert_no_candidate()
|
|
|
|
def test_stdout_download_does_not_replace_or_test_working_config(self):
|
|
self.prepare()
|
|
result = self.run_shell("render_client_config --stdout")
|
|
self.assertEqual(result.returncode, 0, result.stderr)
|
|
self.assertEqual(json.loads(result.stdout)["outbounds"][3]["settings"]["id"], SSH_UUID)
|
|
self.assertFalse(self.directory.joinpath("xray-tests").exists())
|
|
self.assertEqual(self.target.read_bytes(), self.directory.joinpath("original.json").read_bytes())
|
|
self.assert_no_candidate()
|
|
|
|
def test_json_escaping_preserves_controls_quotes_and_unicode(self):
|
|
value = 'a\\b"c\td\ne\rf\x01 Дом\n\n'
|
|
result = self.run_shell('json_string "$TEST_VALUE"', TEST_VALUE=value)
|
|
self.assertEqual(result.returncode, 0, result.stderr)
|
|
self.assertEqual(json.loads(result.stdout), value)
|
|
|
|
@unittest.skipUnless(os.environ.get("OWRT_TEST_XRAY_BIN"), "Set OWRT_TEST_XRAY_BIN to exercise real Xray")
|
|
def test_real_xray_accepts_candidate_and_rejects_flow_without_replacing(self):
|
|
self.prepare(xray_bin=Path(os.environ["OWRT_TEST_XRAY_BIN"]).as_posix())
|
|
result = self.run_shell("render_client_config")
|
|
self.assertEqual(result.returncode, 0, result.stderr)
|
|
self.assertIn("Configuration OK", result.stderr)
|
|
working = self.target.read_bytes()
|
|
self.config(vps_host="hub.example", vps_port="8443", vless_uuid=ADMIN_UUID,
|
|
ssh_vless_uuid=SSH_UUID, reverse_tag="main:admin", ssh_reverse_tag="main:ssh",
|
|
vless_flow="not-supported", xray_bin=Path(os.environ["OWRT_TEST_XRAY_BIN"]).as_posix(),
|
|
xray_config=self.target.as_posix())
|
|
result = self.run_shell("render_client_config")
|
|
self.assertEqual(result.returncode, 23, result.stderr)
|
|
self.assertIn('flow', result.stderr)
|
|
self.assertIn('not-supported', result.stderr)
|
|
self.assertNotIn('Configuration OK', result.stderr)
|
|
self.assertEqual(self.target.read_bytes(), working)
|
|
self.assert_no_candidate()
|
|
|
|
def test_hub_client_and_server_payload_agree_on_uuids_ports_and_routes(self):
|
|
row = dict(id="test-router", name="test", role="node", vps_host="hub.example", vless_port=8443,
|
|
vless_uuid=ADMIN_UUID, ssh_vless_uuid=SSH_UUID, reverse_tag="main:admin", ssh_reverse_tag="main:ssh",
|
|
vless_encryption="none", vless_flow="", admin_host="127.0.0.1", admin_port=80,
|
|
ssh_host="127.0.0.1", ssh_port=22, entry_port=18100, ssh_entry_port=18200)
|
|
payload = shell_tests.hub.build_openwrt_config_payload(row, "https://hub.example")
|
|
self.prepare(vps_host=payload["vps_host"], vps_port=str(payload["vps_port"]),
|
|
vless_uuid=payload["vless_uuid"], ssh_vless_uuid=payload["ssh_vless_uuid"],
|
|
reverse_tag=payload["reverse_tag"], ssh_reverse_tag=payload["ssh_reverse_tag"])
|
|
result = self.run_shell("render_client_config --stdout")
|
|
self.assertEqual(result.returncode, 0, result.stderr)
|
|
client = json.loads(result.stdout)
|
|
server = shell_tests.hub.make_server_xray_config([row], listen_port=8443)
|
|
inbound = server["inbounds"][0]
|
|
self.assertEqual(inbound["port"], client["outbounds"][2]["settings"]["port"])
|
|
users = inbound["settings"]["clients"]
|
|
self.assertEqual([x["id"] for x in users],
|
|
[client["outbounds"][i]["settings"]["id"] for i in (2, 3)])
|
|
# Each end names its reverse stream locally. Client routing uses its
|
|
# own tags; server routing uses the tags assigned to its two users.
|
|
for i, outbound_index in enumerate((2, 3)):
|
|
self.assertEqual(client["routing"]["rules"][i]["inboundTag"],
|
|
[client["outbounds"][outbound_index]["settings"]["reverse"]["tag"]])
|
|
self.assertEqual(server["routing"]["rules"][i]["outboundTag"], users[i]["reverse"]["tag"])
|
|
|
|
def test_uclient_empty_proxy_context_failure_is_reproduced_then_removed(self):
|
|
self.prepare()
|
|
self.env.update(http_proxy="", https_proxy="", HTTP_PROXY="http://unwanted.example:8080",
|
|
ALL_PROXY="socks5://unwanted.example:1080")
|
|
# Mirrors uclient's getenv(pointer) check: an exported empty value is
|
|
# still a proxy URL, and uclient_new("") fails before any request.
|
|
mocks = r'''
|
|
command() {
|
|
if [ "$1" = -v ]; then
|
|
case "$2" in
|
|
curl) return 1 ;;
|
|
wget) [ "$TEST_FETCH_TOOL" = wget ]; return ;;
|
|
uclient-fetch) [ "$TEST_FETCH_TOOL" = uclient-fetch ]; return ;;
|
|
esac
|
|
fi
|
|
builtin command "$@"
|
|
}
|
|
wget() { fake_uclient; }
|
|
uclient-fetch() { fake_uclient; }
|
|
fake_uclient() {
|
|
if [ "${http_proxy+x}" = x ] || [ "${https_proxy+x}" = x ]; then
|
|
echo 'Failed to allocate uclient context' >&2
|
|
return 1
|
|
fi
|
|
[ "${HTTP_PROXY+x}" != x ] && [ "${ALL_PROXY+x}" != x ] || return 97
|
|
printf '{"ok":true}'
|
|
}
|
|
'''
|
|
for tool in ("wget", "uclient-fetch"):
|
|
with self.subTest(tool=tool):
|
|
broken = self.run_shell(mocks + '\nfake_uclient', TEST_FETCH_TOOL=tool)
|
|
self.assertEqual(broken.returncode, 1)
|
|
self.assertIn("Failed to allocate uclient context", broken.stderr)
|
|
result = self.run_shell(mocks + '\npost_json https://hub.example/api/heartbeat token /tmp/payload',
|
|
TEST_FETCH_TOOL=tool)
|
|
self.assertEqual(result.returncode, 0, result.stderr)
|
|
self.assertEqual(json.loads(result.stdout), {"ok": True})
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|