From 4a398c96b16ba62328c97fd693fce7fd67054a9f Mon Sep 17 00:00:00 2001 From: kzolotarev95 Date: Wed, 14 Oct 2026 20:39:24 +0400 Subject: [PATCH] Fix router Xray validation and heartbeat error reporting --- files/usr/sbin/owrt-remote | 135 +++++++++++--- files/www/cgi-bin/owrt-remote | 32 +++- tests/XRAY_APPLY.md | 73 ++++++++ tests/test_host_policy.py | 6 +- tests/test_wan_failover.py | 2 +- tests/test_xray_apply.py | 148 +++++++++++++++ tests/test_xray_validation.py | 257 +++++++++++++++++++++++++++ tests/test_xray_validation_deploy.py | 86 +++++++++ vps/deploy-xray-validation-fix.ps1 | 125 +++++++++++++ 9 files changed, 834 insertions(+), 30 deletions(-) create mode 100644 tests/test_xray_validation.py create mode 100644 tests/test_xray_validation_deploy.py create mode 100644 vps/deploy-xray-validation-fix.ps1 diff --git a/files/usr/sbin/owrt-remote b/files/usr/sbin/owrt-remote index 97971ce..9bb753c 100644 --- a/files/usr/sbin/owrt-remote +++ b/files/usr/sbin/owrt-remote @@ -55,7 +55,20 @@ truthy() { } json_escape() { - printf '%s' "$1" | sed 's/\\/\\\\/g; s/"/\\"/g; s/ /\\t/g' + # The final sentinel retains trailing newlines through awk's record split. + printf '%s.' "$1" | LC_ALL=C awk ' + BEGIN { for (i = 1; i < 32; i++) escape[sprintf("%c", i)] = sprintf("\\u%04x", i) } + { if (NR > 1) value = value "\n"; value = value $0 } + END { + value = substr(value, 1, length(value) - 1) + for (i = 1; i <= length(value); i++) { + char = substr(value, i, 1) + if (char == "\\") printf "\\\\" + else if (char == "\"") printf "\\\"" + else if (char in escape) printf "%s", escape[char] + else printf "%s", char + } + }' } json_string() { @@ -516,8 +529,62 @@ service_enabled() { /etc/init.d/owrt-remote enabled >/dev/null 2>&1 } -render_client_config() { - local out stdout router_id vps_host vps_port uuid ssh_uuid encryption flow reverse_tag ssh_reverse_tag admin_host admin_port ssh_host ssh_port xray_config xray_config_dir +xray_apply_trace() { + [ -z "${OWRT_REMOTE_APPLY_TRACE:-}" ] || printf '%s\n' "$1" >>"$OWRT_REMOTE_APPLY_TRACE" + return 0 +} + +xray_valid_uuid() { + [ "${#1}" = 36 ] || return 1 + printf '%s\n' "$1" | LC_ALL=C grep -Eq '^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$' +} + +xray_port() { + LC_ALL=C awk -v value="$2" -v field="$1" 'BEGIN { + if (value !~ /^[0-9]+$/ || value + 0 < 1 || value + 0 > 65535) { + printf "ОШИБКА: %s должен быть целым числом от 1 до 65535\n", field > "/dev/stderr" + exit 1 + } + printf "%d", value + 0 + }' +} + +xray_valid_tag() { + [ -n "$2" ] || { log "ОШИБКА: $1 пустой"; return 1; } + # OpenWrt's BusyBox tr normally has character classes disabled. Use + # explicit ASCII bytes; [:space:][:cntrl:] would delete ordinary letters. + if [ "$(printf '%s' "$2" | LC_ALL=C tr -d '\001-\040\177')" != "$2" ]; then + log "ОШИБКА: $1 содержит пробел или управляющий символ; метка должна сохраняться из OpenWrt config без изменений" + return 1 + fi + case "$2" in router-admin|router-ssh|vps-interconn|vps-ssh-interconn) + log "ОШИБКА: $1 совпадает с внутренней меткой клиента"; return 1 ;; + esac +} + +validate_xray_config() { + local file binary rc + file="$1" + binary="$(xray_bin_path)" + [ -s "$file" ] || { log "ОШИБКА: конфигурация Xray отсутствует или пуста: $file"; return 1; } + [ -x "$binary" ] || { log "ОШИБКА: Xray не найден или не исполняемый: $binary"; return 1; } + printf 'Проверка Xray: %s -test -config %s\n' "$binary" "$file" >&2 + if "$binary" -test -config "$file" >&2; then + return 0 + else + rc=$? + printf 'Проверка Xray не пройдена (rc=%s). Рабочий JSON не заменён.\n' "$rc" >&2 + return "$rc" + fi +} + +render_client_config() ( + local temp_dir rc xray_host out stdout router_id vps_host vps_port uuid ssh_uuid encryption flow reverse_tag ssh_reverse_tag admin_host admin_port ssh_host ssh_port xray_config xray_config_dir + temp_dir="" + out="" + trap 'rm -f "$out"; [ -z "$temp_dir" ] || rmdir "$temp_dir" 2>/dev/null || true' EXIT + trap 'exit 1' INT TERM + umask 077 stdout="0" if [ "${1:-}" = "--stdout" ]; then stdout="1" @@ -534,30 +601,46 @@ render_client_config() { wan_xray_device="$(wan_device)" || die "выбранный WAN интерфейс отключился" wan_sockopt=", \"sockopt\": {\"mark\": $((PODKOP_BYPASS_MARK)), \"interface\": \"$(json_escape "$wan_xray_device")\"}" fi - vps_port="$(safe_num "$(uci_get vps_port 8443)" 8443)" + vps_port="$(xray_port vps_port "$(uci_get vps_port 8443)")" || return 1 uuid="$(uci_get vless_uuid '')" ssh_uuid="$(uci_get ssh_vless_uuid '')" encryption="$(uci_get vless_encryption none)" flow="$(uci_get vless_flow '')" - reverse_tag="$(safe_id "$(uci_get reverse_tag reverse-in)")" - ssh_reverse_tag="$(safe_id "$(uci_get ssh_reverse_tag "${reverse_tag}-ssh")")" + reverse_tag="$(uci_get reverse_tag reverse-in)" + ssh_reverse_tag="$(uci_get ssh_reverse_tag "${reverse_tag}-ssh")" admin_host="$(uci_get admin_host 127.0.0.1)" - admin_port="$(safe_num "$(uci_get admin_port 80)" 80)" + admin_port="$(xray_port admin_port "$(uci_get admin_port 80)")" || return 1 ssh_host="$(uci_get ssh_host 127.0.0.1)" - ssh_port="$(safe_num "$(uci_get ssh_port 22)" 22)" + ssh_port="$(xray_port ssh_port "$(uci_get ssh_port 22)")" || return 1 xray_config="$(uci_get xray_config /etc/xray/owrt-remote-client.json)" [ -n "$vps_host" ] || die "vps_host пустой" [ -n "$uuid" ] || die "vless_uuid пустой" [ -n "$ssh_uuid" ] || ssh_uuid="$uuid" + xray_valid_uuid "$uuid" || die "vless_uuid: ожидается UUID в формате 8-4-4-4-12; значение не исправляется автоматически" + xray_valid_uuid "$ssh_uuid" || die "ssh_vless_uuid: ожидается UUID в формате 8-4-4-4-12; значение не исправляется автоматически" + [ -z "$(uci_get ssh_vless_uuid '')" ] || [ "$uuid" != "$ssh_uuid" ] || die "vless_uuid и ssh_vless_uuid должны различаться для двух reverse-туннелей" + xray_valid_tag reverse_tag "$reverse_tag" || return 1 + xray_valid_tag ssh_reverse_tag "$ssh_reverse_tag" || return 1 + [ "$reverse_tag" != "$ssh_reverse_tag" ] || die "reverse_tag и ssh_reverse_tag должны различаться" + for xray_host in "$vps_host" "$admin_host" "$ssh_host"; do + [ -n "$xray_host" ] || die "VPS/admin/SSH host пустой" + if [ "$(printf '%s' "$xray_host" | LC_ALL=C tr -d '\001-\040\177')" != "$xray_host" ]; then + die "VPS/admin/SSH host содержит пробел или управляющий символ" + fi + done + case "$vps_host" in *://*|*/*) die "vps_host должен содержать IP или домен без http(s):// и пути" ;; esac if [ "$stdout" = "1" ]; then - out="${TMPDIR:-/tmp}/owrt-remote-client.$$" + xray_config_dir="${TMPDIR:-/tmp}" else xray_config_dir="$(dirname "$xray_config")" - mkdir -p "$xray_config_dir" - out="$xray_config_dir/.owrt-remote-client.$$" + mkdir -p "$xray_config_dir" || return 1 fi + temp_dir="$(mktemp -d "$xray_config_dir/.owrt-remote-client.XXXXXX")" || return 1 + # Xray detects JSON by extension; keep the candidate private and on the + # same filesystem as the destination so the final rename is atomic. + out="$temp_dir/config.json" cat >"$out" <&2 || return 1 + validate_xray_config "$out" || return $? + mv -f "$out" "$xray_config" || return 1 printf '%s\n' "$xray_config" -} +) run_xray() { local enabled xray_bin xray_config @@ -727,11 +813,14 @@ heartbeat_json() { EOF } -post_json() { +post_json() ( local url token file url="$1" token="$2" file="$3" + # uclient treats an empty *_proxy env value as a proxy URL, then fails + # to allocate its client for that empty URL. Remove variables entirely. + unset http_proxy https_proxy HTTP_PROXY HTTPS_PROXY ALL_PROXY all_proxy if truthy "$(uci_get wan_direct 0)"; then wan_post_json "$url" "$token" "$file" return @@ -746,21 +835,21 @@ post_json() { return fi if command -v wget >/dev/null 2>&1; then - http_proxy= https_proxy= HTTP_PROXY= HTTPS_PROXY= ALL_PROXY= all_proxy= wget -q -T 10 -O - \ + wget -q -T 10 -O - \ --header="Authorization: Bearer $token" \ --header="Content-Type: application/json" \ --post-file="$file" "$url" return fi if command -v uclient-fetch >/dev/null 2>&1; then - http_proxy= https_proxy= HTTP_PROXY= HTTPS_PROXY= ALL_PROXY= all_proxy= uclient-fetch -q -T 10 -O - \ + uclient-fetch -q -T 10 -O - \ --header="Authorization: Bearer $token" \ --header="Content-Type: application/json" \ --post-file="$file" "$url" return fi die "для heartbeat нужен uclient-fetch, wget или curl" -} +) global_logs_state() { local enabled xray @@ -1336,13 +1425,17 @@ case "$cmd" in stop_xray ;; render-client) - render_client_config "$@" + xray_apply_trace render-client + render_client_config "$@" || exit $? + xray_apply_trace render-client-ok ;; run) run_xray ;; heartbeat) - send_heartbeat "$@" + xray_apply_trace heartbeat + send_heartbeat "$@" || exit $? + xray_apply_trace heartbeat-ok ;; heartbeat-loop) heartbeat_loop diff --git a/files/www/cgi-bin/owrt-remote b/files/www/cgi-bin/owrt-remote index bb60599..e7e659d 100644 --- a/files/www/cgi-bin/owrt-remote +++ b/files/www/cgi-bin/owrt-remote @@ -262,17 +262,19 @@ normalize_xray_settings() { } apply_xray_settings() { - local script script_file output rc + local script script_file output trace stage rc # HTML textarea POSTs use CRLF, even when the copied Hub commands use LF. # BusyBox ash treats the trailing CR as part of keywords such as then/fi. XRAY_SETTINGS_DRAFT="$(param xray_settings_script | tr -d '\r')" script="$(printf '%s\n' "$XRAY_SETTINGS_DRAFT" | normalize_xray_settings)" output="${TMPDIR:-/tmp}/owrt-remote-apply.$$" script_file="${TMPDIR:-/tmp}/owrt-remote-apply-script.$$" + trace="${TMPDIR:-/tmp}/owrt-remote-apply-trace.$$" rc=0 SHOW_XRAY_SETTINGS="1" - if [ -z "$(printf '%s' "$script" | tr -d '[:space:]')" ]; then + # BusyBox tr in OpenWrt does not enable [:space:] by default. + if [ -z "$(printf '%s' "$script" | tr -d ' \t\r\n\v\f')" ]; then set_result "Xray настройки" "Вставь команды из OpenWrt config на VPS и нажми Применить." "warn" return fi @@ -295,16 +297,36 @@ rc=$rc" "bad" return fi + : >"$trace" + chmod 600 "$trace" 2>/dev/null || true + export OWRT_REMOTE_APPLY_TRACE="$trace" if sh -e "$script_file" >"$output" 2>&1; then XRAY_SETTINGS_DRAFT="" set_result "Xray настройки применены" "$(cat "$output")" "ok" else rc=$? - set_result "Ошибка применения Xray настроек" "$(cat "$output") + stage="$(tail -n 1 "$trace" 2>/dev/null)" + case "$stage" in + heartbeat) + set_result "Ошибка отправки Heartbeat после применения настроек" "$(cat "$output") rc=$rc -Вставленные команды сохранены в поле ниже. Проверь полный блок OpenWrt config: каждая команда должна быть на отдельной строке." "bad" +Сбой произошёл на отправке Heartbeat, а не при проверке JSON Xray. Ранее выполненные команды уже применены. Проверь указанный выше ответ HTTP-клиента и адрес Hub. +Вставленные команды сохранены в поле ниже." "bad" + ;; + render-client) + set_result "Ошибка проверки конфигурации Xray" "$(cat "$output") +rc=$rc +Новый JSON не установлен; перезапуск из этого блока не выполнен. Рабочий файл конфигурации сохранён. Уже записанные команды UCI не отменяются автоматически. +Вставленные команды сохранены в поле ниже." "bad" + ;; + *) + set_result "Ошибка применения Xray настроек" "$(cat "$output") +rc=$rc +Команда завершилась с ошибкой. Причина — в выводе выше; этот код сам по себе не означает ошибку форматирования. Вставленные команды сохранены в поле ниже." "bad" + ;; + esac fi - rm -f "$script_file" "$output" + rm -f "$script_file" "$output" "$trace" } run_action() { diff --git a/tests/XRAY_APPLY.md b/tests/XRAY_APPLY.md index 930fee2..d9ef20b 100644 --- a/tests/XRAY_APPLY.md +++ b/tests/XRAY_APPLY.md @@ -99,3 +99,76 @@ powershell.exe -NoProfile -ExecutionPolicy Bypass -File "C:\Users\k.zolotarev95\ ```powershell python tests/test_xray_mobile_deploy.py -v ``` + + +## Проверка Xray и ошибка Heartbeat после применения (локальный фикс v116) + +В предоставленном журнале Xray 26.3.27 запускается успешно, а завершающая +команда `owrt-remote heartbeat` возвращает `rc=1` с `Failed to allocate +uclient context`. Это ошибка HTTP-клиента, не JSON и не переносов строк. +В старом `post_json` переменные `http_proxy`/`https_proxy` экспортировались +пустыми. uclient проверяет наличие указателя `getenv`, пытается создать +клиент для пустого адреса прокси и возвращает эту ошибку ещё до запроса. +Теперь переменные удаляются через `unset` в отдельной оболочке; внешний +процесс и его настройки прокси не изменяются, проверка TLS остаётся включённой. +Источник: [uclient-fetch](https://github.com/openwrt/uclient/blob/master/uclient-fetch.c). + +При генерации проверяются UUID, диапазон портов 1–65535 и независимость +меток двух reverse-туннелей. Метки больше не изменяются через `safe_id`; +значение сохраняется буквально либо отклоняется с конкретной причиной. +JSON экранирует управляющие символы; порты записываются в десятичном виде, +в том числе при вводе с ведущими нулями. Идентификаторы пользователей и порт +сверены с генераторами клиента/сервера Hub в локальном тесте. Метки reverse +локальны для каждой стороны; они должны совпадать с правилами маршрутизации +своей стороны, а не обязательно иметь одинаковые имена на VPS и роутере. +Фактические настройки удалённого VPS этот локальный тест не проверяет. + +Проверка меток и host не использует классы символов `tr`: в стандартной +сборке OpenWrt 24.10 `FEATURE_TR_CLASSES` выключен. Запись +`tr -d '[:space:][:cntrl:]'` там удаляет обычные буквы из названий классов +и ошибочно отклоняет корректный `reverse-in`. Используется явный диапазон +ASCII-пробела/управляющих байтов; исходные метки не меняются. Проверка пустого +поля CGI также использует явные пробельные символы. Регрессия воспроизводит +старое поведение без классов, проверяет обе метки из конфигурации Hub, +host и применение всего блока через POST с CRLF. Конкретные ключи из +пользовательского `cfg.txt` в тестах не сохраняются. +Источник: [настройки BusyBox OpenWrt 24.10](https://github.com/openwrt/openwrt/blob/openwrt-24.10/package/utils/busybox/Config-defaults.in). + +Новый файл создаётся с правами 0600 в приватной папке рядом с рабочим JSON +и имеет расширение `.json`. До атомарной замены выполняется +`xray -test -config `; используется фактический бинарник, +включая `/tmp/owrt-xray/xray`. Полный вывод и код Xray сохраняются. При +отказе временный файл удаляется, рабочий JSON не заменяется, следующие +команды блока (enable/restart/heartbeat) не выполняются. Проверка Xray +валидирует конфигурацию, но не подтверждает доступность VPS по сети. + +CGI получает этап выполнения от агента. Ошибка Heartbeat показывается +отдельно, с настоящим выводом HTTP-клиента и указанием, что предшествующие +команды уже выполнены. Реальная ошибка Xray показывается отдельно; общий +`rc=1` больше не сопровождается советом о переносах строк. Проверка +синтаксиса `sh -n` и мобильная нормализация сохраняются. При любом отказе +вставленный блок остаётся в поле; уже записанные UCI-настройки не откатываются +автоматически, что явно указано в сообщении. + +Новый скрипт `vps/deploy-xray-validation-fix.ps1` обновляет CGI и агент, +не пересобирает настройки и не перезапускает службы при установке/откате. +Первая резервная копия обоих файлов: +`/root/owrt-remote-backup-before-xray-validation-v116`. Если установка +оборвалась или проверка файлов не прошла, возвращаются файлы до этой попытки. +На роутере друга нужно указать его доступный SSH-адрес вместо локального IP. + +```powershell +powershell.exe -NoProfile -ExecutionPolicy Bypass -File "C:\Users\k.zolotarev95\Documents\openwrt overlay\vps\deploy-xray-validation-fix.ps1" -Router "root@192.168.2.1" -Action Install +``` + +Откат кода (настройки, уже применённые через форму, сохраняются): + +```powershell +powershell.exe -NoProfile -ExecutionPolicy Bypass -File "C:\Users\k.zolotarev95\Documents\openwrt overlay\vps\deploy-xray-validation-fix.ps1" -Router "root@192.168.2.1" -Action Rollback +``` + +Дополнительные тесты: `tests/test_xray_validation.py` и +`tests/test_xray_validation_deploy.py`. Для проверки реальным Xray задайте +`OWRT_TEST_XRAY_BIN`; проверялась версия 26.3.27 (Windows amd64), включая +настоящий отказ неподдерживаемого `flow` с кодом 23. Отдельный mock проверяет +ошибку с кодом 1, который тоже должен сохраняться без подмены причины. diff --git a/tests/test_host_policy.py b/tests/test_host_policy.py index bd2c509..1abba67 100644 --- a/tests/test_host_policy.py +++ b/tests/test_host_policy.py @@ -268,7 +268,7 @@ class RouterShellTests(unittest.TestCase): (self.directory / "uci").write_text("".join(f"owrtremote.main.{key}={value}\n" for key, value in kwargs.items()), encoding="utf-8") def run_shell(self, commands, **env): - return subprocess.run([SH], input=self.agent + "\n" + MOCKS + "\n" + commands, encoding="utf-8", capture_output=True, env={**self.env, **env}, cwd=ROOT, timeout=30) + return subprocess.run([SH], input=self.agent + "\n" + MOCKS + "\n" + commands, encoding="utf-8", capture_output=True, env={**self.env, **env}, cwd=ROOT, timeout=60 if os.name == "nt" else 30) def test_old_and_explicit_manual_modes_ignore_host_rewrite(self): response = {"hub_update": {"vps_host": "hub.example", "hub_url": "https://hub.example", "public_url": "https://hub.example"}} @@ -435,7 +435,7 @@ printf '%s' "$(uci_get hub_url '')" self.assertIn("<--post303>", args) def test_busybox_empty_table_is_confirmed_before_wan_start(self): - self.config(vps_host="193.233.82.38", hub_url="https://hub.example", wan_direct="1", vless_uuid="test-uuid") + self.config(vps_host="193.233.82.38", hub_url="https://hub.example", wan_direct="1", vless_uuid="11111111-1111-4111-8111-111111111111") result = self.run_shell('render_client_config --stdout', TABLE_QUERY_ERROR="busybox") self.assertEqual(result.returncode, 0, result.stderr) config = json.loads(result.stdout) @@ -596,7 +596,7 @@ post_json http://hub.example/api/heartbeat test-token "$TEST_ROOT/payload" self.assertFalse((self.directory / "owrt-remote-wan/lock").exists()) def test_xray_only_reverse_sockets_are_bound_to_wan(self): - self.config(vps_host="193.233.82.38", wan_direct="1", vless_uuid="test-uuid") + self.config(vps_host="193.233.82.38", wan_direct="1", vless_uuid="11111111-1111-4111-8111-111111111111") result = self.run_shell("render_client_config --stdout") self.assertEqual(result.returncode, 0, result.stderr) config = json.loads(result.stdout) diff --git a/tests/test_wan_failover.py b/tests/test_wan_failover.py index f537c4e..672a67c 100644 --- a/tests/test_wan_failover.py +++ b/tests/test_wan_failover.py @@ -72,7 +72,7 @@ class WanFailoverTests(unittest.TestCase): def prepare(self, interfaces="wan wwan modem4g"): self.config(wan_interface=interfaces, wan_direct="1", vps_host="192.0.2.10", vps_host_mode="manual", - hub_url="https://hub.example", hub_token="test-token", vless_uuid="test-uuid") + hub_url="https://hub.example", hub_token="test-token", vless_uuid="11111111-1111-4111-8111-111111111111") self.directory.joinpath("jsonfilter.py").write_text(JSONFILTER, encoding="utf-8") def shell(self, commands): diff --git a/tests/test_xray_apply.py b/tests/test_xray_apply.py index 85d57f3..e1c4c3d 100644 --- a/tests/test_xray_apply.py +++ b/tests/test_xray_apply.py @@ -1,5 +1,6 @@ """Exercise the real router CGI POST with LF/CRLF and a strict POSIX shell.""" import importlib.util +import json import os from pathlib import Path import shutil @@ -175,6 +176,86 @@ render_page() { printf 'KIND=%s\nTITLE=%s\nBODY=%s\nDRAFT=%s\n' "$RESULT_KIND" " self.assertIn("rc=7", response) self.assertFalse(self.directory.joinpath("restarted").exists()) + def test_runtime_rc_one_does_not_blame_mobile_command_format(self): + response = self.post("printf '%s\\n' 'Real command failure' >&2\nexit 1\n") + self.assertIn("KIND=bad", response) + self.assertIn("rc=1", response) + self.assertIn("Real command failure", response) + self.assertNotIn("каждая команда должна быть на отдельной строке", response) + + def test_xray_and_heartbeat_failures_have_distinct_stages_and_keep_draft(self): + for stage in ("render-client", "heartbeat"): + with self.subTest(stage=stage): + script = ('printf "%s\\n" "' + stage + '" >>"$OWRT_REMOTE_APPLY_TRACE"\n' + "printf '%s\\n' 'Failed to allocate uclient context' >&2\nexit 1\n") + response = self.post(script.replace("\n", "\r\n")) + self.assertIn("KIND=bad", response) + self.assertIn("rc=1", response) + self.assertIn("Failed to allocate uclient context", response) + self.assertIn("DRAFT=" + script.rstrip("\n"), response) + self.assertNotIn("каждая команда должна быть на отдельной строке", response) + if stage == "heartbeat": + self.assertIn("Ошибка отправки Heartbeat после применения настроек", response) + self.assertNotIn("Ошибка проверки конфигурации Xray", response) + else: + self.assertIn("Ошибка проверки конфигурации Xray", response) + self.assertIn("Рабочий файл конфигурации сохранён", response) + + def test_real_agent_heartbeat_failure_is_labeled_without_blaming_xray(self): + agent = (ROOT / "files/usr/sbin/owrt-remote").read_text(encoding="utf-8") + mocks = r''' +uci_get() { + case "$1" in hub_url) printf https://hub.example ;; hub_token) printf test-token ;; vps_host) printf hub.example ;; *) printf '%s' "$2" ;; esac +} +heartbeat_json() { printf '{"id":"test-router"}'; } +post_json() { echo 'Failed to allocate uclient context' >&2; return 1; } +logger() { :; } +''' + tools = self.directory / "bin" + tools.joinpath("owrt-remote").write_text(agent.replace('cmd="${1:-help}"', mocks + '\ncmd="${1:-help}"', 1), + encoding="utf-8", newline="\n") + tools.joinpath("owrt-remote").chmod(0o755) + script = 'printf restarted >"$TEST_ROOT/restarted"\nowrt-remote heartbeat\n' + response = self.post(script.replace("\n", "\r\n")) + self.assertIn("KIND=bad", response) + self.assertIn("Ошибка отправки Heartbeat после применения настроек", response) + self.assertIn("Failed to allocate uclient context", response) + self.assertNotIn("каждая команда должна быть на отдельной строке", response) + self.assertTrue(self.directory.joinpath("restarted").exists()) + + @unittest.skipUnless(os.environ.get("OWRT_TEST_XRAY_BIN"), "Set OWRT_TEST_XRAY_BIN to exercise real Xray") + def test_mobile_post_shows_real_xray_error_before_restart_and_keeps_json(self): + target = self.directory / "working.json" + target.write_text('{"previous":true}\n', encoding="utf-8") + self.env["TEST_XRAY_BIN"] = Path(os.environ["OWRT_TEST_XRAY_BIN"]).as_posix() + agent = (ROOT / "files/usr/sbin/owrt-remote").read_text(encoding="utf-8") + mocks = r''' +uci_get() { + case "$1" in + vps_host) printf hub.example ;; vless_uuid) printf 11111111-1111-4111-8111-111111111111 ;; + ssh_vless_uuid) printf 22222222-2222-4222-8222-222222222222 ;; + xray_config) printf '%s/working.json' "$TEST_ROOT" ;; xray_bin) printf '%s' "$TEST_XRAY_BIN" ;; + vless_flow) printf not-supported ;; *) printf '%s' "$2" ;; + esac +} +ensure_xray_available() { return 0; } +logger() { :; } +''' + executable = self.directory / "bin/owrt-remote" + executable.write_text(agent.replace('cmd="${1:-help}"', mocks + '\ncmd="${1:-help}"', 1), + encoding="utf-8", newline="\n") + executable.chmod(0o755) + script = 'owrt-remote render-client\nprintf restarted >"$TEST_ROOT/restarted"\n' + response = self.post(script.replace("\n", "\r\n")) + self.assertIn("KIND=bad", response) + self.assertIn("Ошибка проверки конфигурации Xray", response) + self.assertIn('VLESS users: "flow"', response) + self.assertIn("not-supported", response) + self.assertIn("rc=23", response) + self.assertFalse(self.directory.joinpath("restarted").exists()) + self.assertEqual(target.read_text(), '{"previous":true}\n') + self.assertFalse(list(self.directory.glob(".owrt-remote-client.*"))) + def test_empty_and_unauthorized_form_do_not_execute_commands(self): self.assertIn("KIND=warn", self.post(" \r\n\t\r\n")) self.assertFalse(self.directory.joinpath("calls").exists()) @@ -183,6 +264,73 @@ render_page() { printf 'KIND=%s\nTITLE=%s\nBODY=%s\nDRAFT=%s\n' "$RESULT_KIND" " self.assertFalse(self.directory.joinpath("applied").exists()) self.assertFalse(self.directory.joinpath("calls").exists()) + @unittest.skipUnless(os.environ.get("OWRT_TEST_XRAY_BIN"), "Set OWRT_TEST_XRAY_BIN to exercise real Xray") + def test_full_mobile_hub_config_with_classless_openwrt_tr_and_real_xray(self): + from test_xray_validation import ADMIN_UUID, SSH_UUID, CLASSLESS_TR + + self.env["TEST_XRAY_BIN"] = Path(os.environ["OWRT_TEST_XRAY_BIN"]).as_posix() + uci_function = r''' +uci() { + [ "$1" != -q ] || shift + case "$1" in + get) + [ "$2" != owrtremote.main ] || { echo remote; return; } + awk -F= -v key="$2" '$1 == key { sub(/^[^=]*=/, ""); print; found=1; exit } END { if(!found) exit 1 }' "$TEST_ROOT/uci" ;; + set) + key="${2%%=*}"; value="${2#*=}" + awk -F= -v key="$key" '$1 != key' "$TEST_ROOT/uci" >"$TEST_ROOT/uci.new" + printf '%s=%s\n' "$key" "$value" >>"$TEST_ROOT/uci.new" + mv "$TEST_ROOT/uci.new" "$TEST_ROOT/uci" ;; + commit) printf 'commit\n' >>"$TEST_ROOT/operations" ;; + esac +} +''' + self.directory.joinpath("uci").write_text("", encoding="utf-8") + self.directory.joinpath("bin/uci").write_text("#!/bin/sh\n" + uci_function + '\nuci "$@"\n', + encoding="utf-8", newline="\n") + # Both CGI and its separate agent process see a BusyBox-like tr. + self.directory.joinpath("bin/tr").write_text("#!/bin/sh\n" + CLASSLESS_TR.replace("command tr", "command /usr/bin/tr") + '\ntr "$@"\n', + encoding="utf-8", newline="\n") + self.directory.joinpath("bin/tr").chmod(0o755) + agent = (ROOT / "files/usr/sbin/owrt-remote").read_text(encoding="utf-8") + mocks = r''' +uci_get_original() { +__UCI_GET_BODY__ +} +uci_get() { + case "$1" in + xray_config) printf '%s/working.json' "$TEST_ROOT" ;; + xray_bin) printf '%s' "$TEST_XRAY_BIN" ;; + *) uci_get_original "$@" ;; + esac +} +ensure_xray_available() { return 0; } +send_heartbeat() { printf 'heartbeat\n' >>"$TEST_ROOT/operations"; } +logger() { :; } +'''.replace("__UCI_GET_BODY__", agent.split("uci_get() {\n", 1)[1].split("\n}\n", 1)[0]) + executable = self.directory / "bin/owrt-remote" + executable.write_text(agent.replace('cmd="${1:-help}"', CLASSLESS_TR + mocks + '\ncmd="${1:-help}"', 1), + encoding="utf-8", newline="\n") + executable.chmod(0o755) + self.directory.joinpath("working.json").write_text('{"previous":true}\n', encoding="utf-8") + row = {"id": "main", "name": "test", "vps_host": "hub.example", "reverse_tag": "reverse-in", + "ssh_reverse_tag": "reverse-in-ssh", "vless_uuid": ADMIN_UUID, "ssh_vless_uuid": SSH_UUID} + with mock.patch.object(hub, "agent_token", return_value="test-agent-token"): + generated = hub.make_openwrt_config(row, "https://hub.example") + generated = generated.replace("/etc/init.d/owrt-remote", "test_service") + response = self.post(('test_service() { printf "service %s\\n" "$*" >>"$TEST_ROOT/operations"; }\n' + generated).replace("\n", "\r\n")) + self.assertIn("KIND=ok", response) + self.assertIn("Configuration OK", response) + config = json.loads(self.directory.joinpath("working.json").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.directory.joinpath("operations").read_text(), "commit\nservice enable\nservice restart\nheartbeat\n") + self.assertFalse(list(self.directory.glob(".owrt-remote-client.*"))) + self.directory.joinpath("operations").unlink() + self.assertIn("KIND=warn", self.post(" \r\n\t\v\f\r\n")) + self.assertFalse(self.directory.joinpath("operations").exists()) + def test_full_hub_config_through_form_preserves_manual_host_and_wan(self): self.directory.joinpath("uci").write_text("owrtremote.main.vps_host=192.0.2.25\nowrtremote.main.wan_interface=wwan\n", encoding="utf-8") mocks = r''' diff --git a/tests/test_xray_validation.py b/tests/test_xray_validation.py new file mode 100644 index 0000000..b1e19d1 --- /dev/null +++ b/tests/test_xray_validation.py @@ -0,0 +1,257 @@ +"""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() diff --git a/tests/test_xray_validation_deploy.py b/tests/test_xray_validation_deploy.py new file mode 100644 index 0000000..41a1bd8 --- /dev/null +++ b/tests/test_xray_validation_deploy.py @@ -0,0 +1,86 @@ +"""Run installation and rollback in a sandbox, without SSH or services.""" +import os +from pathlib import Path +import shlex +import subprocess +import tempfile +import unittest + +from test_xray_mobile_deploy import SH, GIT_BIN, ROOT + + +@unittest.skipUnless(SH, "POSIX shell required") +class XrayValidationDeploymentTests(unittest.TestCase): + def setUp(self): + self.temp = tempfile.TemporaryDirectory(prefix="xray-validation-deploy-") + self.addCleanup(self.temp.cleanup) + self.root = Path(self.temp.name) + self.targets = {"cgi": self.root / "cgi", "agent": self.root / "agent"} + for name, path in self.targets.items(): + path.write_text("#!/bin/sh\necho previous-" + name + "\n", encoding="utf-8", newline="\n") + self.original = {name: path.read_bytes() for name, path in self.targets.items()} + self.backup = self.root / "backup" + self.env = dict(os.environ) + if os.name == "nt": + self.env["PATH"] = str(GIT_BIN) + os.pathsep + self.env["PATH"] + source = (ROOT / "vps/deploy-xray-validation-fix.ps1").read_text(encoding="utf-8") + self.script = source.split("$RemoteScript = @'\n", 1)[1].split("\n'@", 1)[0] + self.script = self.script.replace("backup_dir=/root/owrt-remote-backup-before-xray-validation-v116", + "backup_dir=" + shlex.quote(self.backup.as_posix())) + self.script = self.script.replace("printf /www/cgi-bin/owrt-remote", "printf %s " + shlex.quote(self.targets["cgi"].as_posix())) + self.script = self.script.replace("printf /usr/sbin/owrt-remote", "printf %s " + shlex.quote(self.targets["agent"].as_posix())) + + def deploy(self, action, bad_item=None, fail_verify=False): + stage = self.root / "stage" + stage.mkdir() + for item, source in {"cgi": "files/www/cgi-bin/owrt-remote", "agent": "files/usr/sbin/owrt-remote"}.items(): + text = (ROOT / source).read_text(encoding="utf-8") + if bad_item == item: + text = "#!/bin/sh\nif true; then\n" + stage.joinpath(item).write_text(text, encoding="utf-8", newline="\n") + script = self.script.replace("stage=/tmp/__UPLOAD_NAME__", "stage=" + shlex.quote(stage.as_posix())) + script = script.replace("__ACTION__", action).replace("__UPLOAD_NAME__", "sandbox") + if fail_verify: + script = script.replace('cmp "$source_dir/$item" "$path"', "false") + result = subprocess.run([SH], input=script, encoding="utf-8", capture_output=True, + env=self.env, timeout=30) + self.assertFalse(stage.exists()) + self.assertFalse(list(self.root.glob("*.new-sandbox"))) + return result + + def test_install_twice_then_rollback_preserves_first_backup(self): + for attempt in range(2): + result = self.deploy("Install") + self.assertEqual(result.returncode, 0, result.stderr) + self.assertIn("XRAY_VALIDATION_ROUTER_Install_OK", result.stdout) + for item, path in self.targets.items(): + self.assertNotEqual(path.read_bytes(), self.original[item]) + self.assertEqual(self.backup.joinpath(item).read_bytes(), self.original[item]) + result = self.deploy("Rollback") + self.assertEqual(result.returncode, 0, result.stderr) + for item, path in self.targets.items(): + self.assertEqual(path.read_bytes(), self.original[item]) + + def test_bad_candidate_and_missing_backup_leave_both_files_unchanged(self): + for item in ("cgi", "agent"): + result = self.deploy("Install", bad_item=item) + self.assertNotEqual(result.returncode, 0) + self.assertFalse(self.backup.exists()) + for name, path in self.targets.items(): + self.assertEqual(path.read_bytes(), self.original[name]) + result = self.deploy("Rollback") + self.assertNotEqual(result.returncode, 0) + self.assertIn("No complete backup", result.stderr) + for name, path in self.targets.items(): + self.assertEqual(path.read_bytes(), self.original[name]) + + def test_verify_failure_restores_both_files(self): + result = self.deploy("Install", fail_verify=True) + self.assertNotEqual(result.returncode, 0) + self.assertIn("Restoring the agent and CGI", result.stderr) + for item, path in self.targets.items(): + self.assertEqual(path.read_bytes(), self.original[item]) + + +if __name__ == "__main__": + unittest.main() diff --git a/vps/deploy-xray-validation-fix.ps1 b/vps/deploy-xray-validation-fix.ps1 new file mode 100644 index 0000000..5f826b0 --- /dev/null +++ b/vps/deploy-xray-validation-fix.ps1 @@ -0,0 +1,125 @@ +param( + [ValidateNotNullOrEmpty()][string]$Router = 'root@192.168.2.1', + [ValidateSet('Install', 'Rollback')][string]$Action = 'Install', + [switch]$PrepareOnly +) + +$ErrorActionPreference = 'Stop' +$RepoRoot = Split-Path -Parent $PSScriptRoot +$UploadName = 'owrt-xray-validation-' + [guid]::NewGuid().ToString('N') +$StageRoot = Join-Path ([System.IO.Path]::GetTempPath()) $UploadName +$Utf8 = [System.Text.UTF8Encoding]::new($false) +$Payloads = @{ + 'cgi' = 'files\www\cgi-bin\owrt-remote' + 'agent' = 'files\usr\sbin\owrt-remote' +} +$RemoteScript = @' +#!/bin/sh +set -eu +stage=/tmp/__UPLOAD_NAME__ +backup_dir=/root/owrt-remote-backup-before-xray-validation-v116 +changed=0 +phase=preflight +item_path() { + case "$1" in + cgi) printf /www/cgi-bin/owrt-remote ;; + agent) printf /usr/sbin/owrt-remote ;; + esac +} +complete_backup() { + [ -f "$1/complete" ] && [ -s "$1/cgi" ] && [ -s "$1/agent" ] +} +restore_files() { + local dir item path + dir=$1 + complete_backup "$dir" || return 1 + for item in cgi agent; do + path=$(item_path "$item") + cp -p "$dir/$item" "$path.new-__UPLOAD_NAME__" || return 1 + mv -f "$path.new-__UPLOAD_NAME__" "$path" || return 1 + done +} +cleanup() { + code=$? + trap - EXIT + if [ "$code" -ne 0 ]; then + printf 'Failed during %s (rc=%s).\n' "$phase" "$code" >&2 + if [ "$changed" = 1 ]; then + echo 'Restoring the agent and CGI from this attempt.' >&2 + restore_files "$stage/previous" || echo 'Restore failed; retained backup is available.' >&2 + fi + fi + for item in cgi agent; do path=$(item_path "$item"); rm -f "$path.new-__UPLOAD_NAME__"; done + rm -rf "$stage" + exit "$code" +} +trap cleanup EXIT +for item in cgi agent; do + path=$(item_path "$item") + test -s "$path" +done +if [ '__ACTION__' = Install ]; then + for item in cgi agent; do test -s "$stage/$item"; sh -n "$stage/$item"; done + grep -F -q 'validate_xray_config()' "$stage/agent" + grep -F -q 'unset http_proxy https_proxy' "$stage/agent" + grep -F -q 'OWRT_REMOTE_APPLY_TRACE' "$stage/cgi" + if [ ! -e "$backup_dir" ]; then + mkdir -p "$stage/retained-backup" + chmod 700 "$stage/retained-backup" + for item in cgi agent; do path=$(item_path "$item"); cp -p "$path" "$stage/retained-backup/$item"; done + touch "$stage/retained-backup/complete" + mv "$stage/retained-backup" "$backup_dir" + fi + complete_backup "$backup_dir" || { echo "Incomplete backup: $backup_dir. Nothing changed." >&2; exit 1; } + source_dir=$stage +else + complete_backup "$backup_dir" || { echo "No complete backup: $backup_dir. Nothing changed." >&2; exit 1; } + for item in cgi agent; do sh -n "$backup_dir/$item"; done + source_dir=$backup_dir +fi +printf 'Backup: %s\n' "$backup_dir" +mkdir -p "$stage/previous" +for item in cgi agent; do path=$(item_path "$item"); cp -p "$path" "$stage/previous/$item"; done +touch "$stage/previous/complete" +phase=install +changed=1 +for item in cgi agent; do + path=$(item_path "$item") + cp "$source_dir/$item" "$path.new-__UPLOAD_NAME__" + chmod 755 "$path.new-__UPLOAD_NAME__" + mv -f "$path.new-__UPLOAD_NAME__" "$path" +done +phase=verify +for item in cgi agent; do + path=$(item_path "$item") + sh -n "$path" + cmp "$source_dir/$item" "$path" +done +# Deploy only code. Do not regenerate config or restart a remote tunnel here. +printf '\nXRAY_VALIDATION_ROUTER_%s_OK\n' '__ACTION__' + +'@ +$RemoteScript = $RemoteScript.Replace('__UPLOAD_NAME__', $UploadName).Replace('__ACTION__', $Action) +try { + [System.IO.Directory]::CreateDirectory($StageRoot) | Out-Null + [System.IO.File]::WriteAllText((Join-Path $StageRoot 'run.sh'), $RemoteScript.Replace("`r`n", "`n") + "`n", $Utf8) + if ($Action -eq 'Install') { + foreach ($Item in $Payloads.GetEnumerator()) { + $Content = [System.IO.File]::ReadAllText((Join-Path $RepoRoot $Item.Value)).Replace("`r`n", "`n") + [System.IO.File]::WriteAllText((Join-Path $StageRoot $Item.Key), $Content, $Utf8) + } + } + if ($PrepareOnly) { Write-Host "Prepared only: $StageRoot"; return } + & scp -O -r -- $StageRoot "${Router}:/tmp/" + if ($LASTEXITCODE -ne 0) { throw 'Upload failed. The installation has not started.' } + & ssh -T -o ConnectTimeout=10 $Router "sh /tmp/$UploadName/run.sh" + if ($LASTEXITCODE -ne 0) { throw "$Action failed. See the output above; success was not confirmed." } + Write-Host "Xray validation fix $Action finished successfully." +} finally { + if (-not $PrepareOnly) { + $Resolved = [System.IO.Path]::GetFullPath($StageRoot) + $Expected = [System.IO.Path]::GetFullPath((Join-Path ([System.IO.Path]::GetTempPath()) $UploadName)) + if ($Resolved -ne $Expected -or (Split-Path -Leaf $Resolved) -ne $UploadName) { throw 'Unsafe staging cleanup path.' } + if (Test-Path -LiteralPath $Resolved) { Remove-Item -LiteralPath $Resolved -Recurse -Force } + } +}