diff --git a/files/usr/lib/owrt-remote/wan.sh b/files/usr/lib/owrt-remote/wan.sh index b997155..0900d05 100644 --- a/files/usr/lib/owrt-remote/wan.sh +++ b/files/usr/lib/owrt-remote/wan.sh @@ -103,37 +103,114 @@ wan_dns_server() { printf '%s' "$dns" } +wan_dns_metric() { + [ -n "${OWRT_REMOTE_DNS_METRICS:-}" ] || return 0 + printf '%s %s\n' "$1" "$2" >"$OWRT_REMOTE_DNS_METRICS" +} + +wan_dns_ipv4() { + # DNS cache entries must be unambiguous IPv4, never IPv6 or a fake-IP. + case "$1" in ''|198.18.*|198.19.*) return 1 ;; esac + printf '%s\n' "$1" | awk -F. ' + NF != 4 { exit 1 } + { for (i=1;i<=4;i++) if ($i !~ /^[0-9]+$/ || $i > 255 || (length($i)>1 && $i ~ /^0/)) exit 1 } + ' +} + +wan_dns_a_reply() { + # BusyBox prints the resolver Address before the answer. Only trust an + # Address belonging to the queried Name (or its CNAME chain), with rc=0. + awk -v host="$1" -v rc="$2" ' + function name(s) { s=tolower(s); sub(/\.$/, "", s); return s } + function ipv4(s, a,n,i) { + n=split(s,a,"."); if (n!=4) return 0 + for(i=1;i<=4;i++) if(a[i]!~/^[0-9]+$/ || a[i]>255 || (length(a[i])>1 && a[i]~/^0/)) return 0 + return 1 + } + BEGIN { allowed[name(host)]=1 } + { + text=tolower($0) + if(text ~ /timed out|connection timeout/) timed_out=1 + if(text ~ /: (no answer|nxdomain|nodata)([[:space:]]|$)/) no_a=1 + if(text ~ /: parse error([[:space:]]|$)/) bad=1 + if(text ~ /: (servfail|refused|formerr|notimp)([[:space:]]|$)/) dns_error=1 + } + /^[[:space:]]*Server:/ { server=1; owner=""; next } + $2 == "canonical" && $3 == "name" && $4 == "=" { + aliases[++alias_count]=name($1); targets[alias_count]=name($5); next + } + /^[[:space:]]*Name:/ { + owner=name($2); named=1 + if(NF!=2 || owner !~ /^[a-z0-9_.-]+$/) { owner=""; bad=1 } + next + } + /^[[:space:]]*Address([[:space:]]+[0-9]+)?:/ { + if(owner=="") next + field=($1=="Address:" ? 2 : 3) + if(ipv4($field)) { + owners[++count]=owner; ips[count]=$field + } else if(index($field,":")==0) bad=1 + } + END { + for(pass=1;pass<=alias_count;pass++) + for(i=1;i<=alias_count;i++) if(allowed[aliases[i]]) allowed[targets[i]]=1 + if(rc==0 && !bad && !dns_error) for(i=1;i<=count;i++) if(allowed[owners[i]]) { + if(ips[i] ~ /^198\.(18|19)\./) { rejected=1; continue } + print "ok", ips[i]; exit + } + if(timed_out) print "timeout" + else if(bad) print "parse_error" + else if(dns_error) print "resolver_error" + else if(rejected) print "rejected_address" + else if(no_a || (rc==0 && count==0 && (server || named))) print "no_a_record" + else if(rc!=0) print "resolver_error" + else print "parse_error" + } + ' +} + wan_resolve_host() { - local host dns answer cache now saved_ts saved_ip + local host dns answer cache now saved_ts saved_ip saved_age started reply rc result reason host="$1" - wan_ip_literal "$host" && { printf '%s' "$host"; return; } + wan_ip_literal "$host" && { wan_dns_metric 0 literal; printf '%s' "$host"; return; } case "$host" in ''|*[!a-zA-Z0-9_.-]*) return 1 ;; esac dns="$(wan_dns_server)" || return 1 cache="$WAN_STATE/resolve-$(safe_id "$host-$dns")" now="$(date +%s)" saved_ts=0; saved_ip='' - [ ! -r "$cache" ] || read -r saved_ts saved_ip <"$cache" - if [ -n "$saved_ip" ] && [ $((now - saved_ts)) -lt 300 ]; then + if [ -r "$cache" ]; then + read -r saved_ts saved_ip <"$cache" || { saved_ts=0; saved_ip=''; } + fi + # Reject corrupted/future timestamps and non-IPv4 cache contents before + # arithmetic or fallback; keep the existing 5 minute / 1 hour limits. + case "$saved_ts" in ''|0*|*[!0-9]*|???????????*) saved_ts=0; saved_ip='' ;; esac + saved_age=$((now - saved_ts)) + if [ "$saved_age" -lt 0 ] || ! wan_dns_ipv4 "$saved_ip"; then saved_ip=''; fi + if [ -n "$saved_ip" ] && [ "$saved_age" -lt 300 ]; then + wan_dns_metric 0 cache printf '%s' "$saved_ip"; return fi # Query WAN's resolver explicitly, never the local dnsmasq/sing-box resolver. - answer="$(nslookup -timeout=3 -retry=1 "$host" "$dns" 2>/dev/null | awk ' - /^Name:/ { in_answer=1 } - in_answer && /^Address([[:space:]][0-9]+)?:/ { - for (i=2;i<=NF;i++) if ($i ~ /^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+$/) { print $i; exit } - }')" - case "$answer" in 198.18.*|198.19.*) answer='' ;; esac - if wan_ip_literal "$answer"; then + started='' + [ -z "${OWRT_REMOTE_DNS_METRICS:-}" ] || started="$(remote_clock_ms)" + # Without -type=A BusyBox queries both A and AAAA, so an empty AAAA + # answer can be confused with an IPv4 failure. Preserve nslookup status. + rc=0 + reply="$(LC_ALL=C nslookup -type=A -timeout=3 -retry=1 "$host" "$dns" 2>&1)" || rc=$? + [ -z "$started" ] || wan_dns_metric "$(( $(remote_clock_ms) - started ))" lookup + result="$(printf '%s\n' "$reply" | wan_dns_a_reply "$host" "$rc")" + reason="${result%% *}"; answer="${result#* }" + if [ "$reason" = ok ] && wan_dns_ipv4 "$answer"; then mkdir -p "$WAN_STATE" printf '%s %s\n' "$now" "$answer" >"$cache.tmp.$$" mv "$cache.tmp.$$" "$cache" printf '%s' "$answer"; return fi - if [ -n "$saved_ip" ] && [ $((now - saved_ts)) -lt 3600 ]; then - log "WAN DNS unavailable for $host; using last successful WAN address $saved_ip" + if [ -n "$saved_ip" ] && [ "$saved_age" -lt 3600 ]; then + log "WAN DNS unavailable for $host; reason=$reason; resolver=$dns; rc=$rc; using last successful WAN address $saved_ip" printf '%s' "$saved_ip"; return fi - log "WAN DNS failed: host=$host resolver=$dns" + log "WAN DNS failed: host=$host resolver=$dns type=A reason=$reason rc=$rc" return 1 } @@ -143,6 +220,7 @@ wan_endpoint_ip() { pinned="$(uci_get vps_host '')" # Preserve HTTP Host and TLS SNI while connecting to the manually pinned VPS. if ! wan_ip_literal "$host" && [ "$(vps_host_mode)" = manual ] && wan_ip_literal "$pinned"; then + wan_dns_metric 0 pinned printf '%s' "$pinned" else wan_resolve_host "$host" @@ -388,9 +466,9 @@ wan_prepare() ( wan_prepare_locked ) -wan_post_json() { - local url token file host port ip device selected OWRT_REMOTE_ACTIVE_WAN_INTERFACE - url="$1"; token="$2"; file="$3" +wan_http_target() { + local url host port ip device selected OWRT_REMOTE_ACTIVE_WAN_INTERFACE + url="$1" selected="$(wan_select_interface)" || return 1 if [ "$selected" != "$(cat "$WAN_STATE/active-interface" 2>/dev/null)" ]; then wan_prepare || return 1 @@ -398,7 +476,7 @@ wan_post_json() { OWRT_REMOTE_ACTIVE_WAN_INTERFACE="$(cat "$WAN_STATE/active-interface")" || return 1 host="$(wan_url_host "$url")" port="$(wan_url_port "$url")" || return 1 - ip="$(wan_endpoint_ip "$url")" || return 1 + ip="$(OWRT_REMOTE_DNS_METRICS="${OWRT_REMOTE_DNS_STATS_FILE:-}" wan_endpoint_ip "$url")" || return 1 device="$(wan_device)" || return 1 # A resolver cache may expire between prepare and this request. Refresh # direct routes before sending to a newly resolved IP. @@ -407,13 +485,12 @@ wan_post_json() { grep -Fqx "$ip $port" "$WAN_STATE/endpoints" || return 1 fi case "$ip" in *:*) ip="[$ip]" ;; esac - # Follow nginx HTTP-to-HTTPS redirects while preserving this JSON POST. - # Host and TLS SNI remain the configured URL's; no certificate bypass is used. - curl -fsSL --location --max-redirs 3 --post301 --post302 --post303 \ - --noproxy '*' --interface "$device" --connect-timeout 4 --max-time 10 \ - --resolve "$host:$port:$ip" \ - -H "Authorization: Bearer $token" -H 'Content-Type: application/json' \ - --data-binary "@$file" "$url" + printf '%s|%s:%s:%s' "$device" "$host" "$port" "$ip" +} + +wan_post_json() { + # Resolve and bind every approved redirect separately, including HTTPS. + remote_curl_post "$1" "$2" "$3" wan } wan_cleanup() { diff --git a/files/usr/sbin/owrt-remote b/files/usr/sbin/owrt-remote index 9bb753c..e520fdf 100644 --- a/files/usr/sbin/owrt-remote +++ b/files/usr/sbin/owrt-remote @@ -28,6 +28,7 @@ usage() { owrt-remote run owrt-remote heartbeat owrt-remote heartbeat-loop + owrt-remote heartbeat-diagnostics owrt-remote logs-sync owrt-remote network-diagnostics @@ -813,6 +814,108 @@ heartbeat_json() { EOF } +remote_clock_ms() { + LC_ALL=C awk '{ printf "%.0f", $1 * 1000; exit }' /proc/uptime 2>/dev/null || date +%s000 +} + +remote_url_origin() { + # Return only a validated origin, never userinfo, path, query or fragment. + printf '%s\n' "$1" | LC_ALL=C awk ' + NR != 1 { bad=1 } + NR == 1 { + if ($0 ~ /[\001-\040\177]/ || $0 !~ /^https?:\/\//) { bad=1; next } + scheme=$0; sub(/:.*/, "", scheme) + authority=$0; sub(/^https?:\/\//, "", authority); sub(/[\/?#].*/, "", authority) + if (authority ~ /@/) { bad=1; next } + port=(scheme == "https" ? 443 : 80) + if (authority ~ /^\[[0-9a-fA-F:]+\](:[0-9]+)?$/) { + host=authority; sub(/\].*/, "]", host) + if (authority ~ /\]:/) { port=authority; sub(/^.*\]:/, "", port) } + } else if (authority ~ /^[a-zA-Z0-9_.-]+(:[0-9]+)?$/) { + host=authority; sub(/:.*/, "", host) + if (authority ~ /:/) { port=authority; sub(/^.*:/, "", port) } + } else { bad=1; next } + if (port + 0 < 1 || port + 0 > 65535) { bad=1; next } + } + END { if (bad || !host) exit 1; printf "%s://%s:%d", scheme, tolower(host), port + 0 } + ' +} + +remote_curl_metrics() { + [ -n "${OWRT_REMOTE_HTTP_METRICS:-}" ] || return 0 + # Parse numeric fields only. redirect_url may contain secrets and is excluded. + LC_ALL=C awk -v secure="$2" -v resolver="$3" -v hop="$4" -v wan_dns="${5:-}" -v source="${6:-curl}" ' + NF >= 6 && $1 ~ /^[0-9][0-9][0-9]$/ { + for (i=2; i<=6; i++) if ($i !~ /^[0-9]+(\.[0-9]+)?$/) exit + dns=sprintf("%.1f", $2*1000); tcp=($3>0 ? sprintf("%.1f", ($3>$2 ? ($3-$2)*1000 : 0)) : "incomplete") + if (source != "curl") dns=(wan_dns ~ /^[0-9]+$/ ? sprintf("%.1f", wan_dns+0) : "n/a") + if (source !~ /^(curl|lookup|cache|literal|pinned|pre_resolved)$/) source="pre_resolved" + tls=(secure == "https" ? ($4>0 ? sprintf("%.1f", ($4>$3 ? ($4-$3)*1000 : 0)) : "incomplete") : "n/a") + printf "tool=curl HTTP=%s DNS_ms=%s TCP_ms=%s TLS_ms=%s TTFB_ms=%.1f total_ms=%.1f WAN_resolve_ms=%d hop=%d DNS_source=%s\n", $1, dns, tcp, tls, $5*1000, $6*1000, resolver, hop, source + exit + }' "$1" >>"$OWRT_REMOTE_HTTP_METRICS" +} + +remote_curl_post() ( + local url token file mode dir rc hop origin next_origin redirect code dns tcp tls first total target device resolve started remaining resolver_started resolver_ms dns_ms dns_source OWRT_REMOTE_DNS_STATS_FILE + url="$1"; token="$2"; file="$3"; mode="${4:-normal}" + origin="$(remote_url_origin "$url")" || return 3 + dir="$(mktemp -d "${TMPDIR:-/tmp}/owrt-remote-http.XXXXXX")" || return 1 + chmod 700 "$dir" + trap 'rm -f "$dir/body" "$dir/stats" "$dir/error" "$dir/dns"; rmdir "$dir" 2>/dev/null || true' EXIT + trap 'exit 1' INT TERM + started="$(remote_clock_ms)"; hop=0 + while :; do + resolver_ms=0; dns_ms=''; dns_source=curl + set -- -q -fsS --connect-timeout 4 --noproxy '*' --proto '=http,https' + if [ "$mode" = wan ]; then + OWRT_REMOTE_DNS_STATS_FILE="$dir/dns"; : >"$dir/dns" + dns_source=pre_resolved + resolver_started="$(remote_clock_ms)" + target="$(wan_http_target "$url")" || return 1 + resolver_ms=$(( $(remote_clock_ms) - resolver_started )) + read -r dns_ms dns_source <"$dir/dns" || true + device="${target%%|*}"; resolve="${target#*|}" + set -- "$@" --interface "$device" --resolve "$resolve" + fi + remaining=$((10000 - $(remote_clock_ms) + started)) + [ "$remaining" -gt 0 ] || return 28 + remaining="$(LC_ALL=C awk -v value="$remaining" 'BEGIN { printf "%.3f", value/1000 }')" + rc=0 + # Each permitted redirect is a separate authenticated POST. curl -L + # drops Bearer auth on an origin change, including HTTP -> HTTPS. + curl "$@" --max-time "$remaining" -o "$dir/body" \ + -w '%{http_code} %{time_namelookup} %{time_connect} %{time_appconnect} %{time_starttransfer} %{time_total} %{redirect_url}\n' \ + -H "Authorization: Bearer $token" -H 'Content-Type: application/json' \ + --data-binary "@$file" "$url" >"$dir/stats" 2>"$dir/error" || rc=$? + remote_curl_metrics "$dir/stats" "${url%%:*}" "$resolver_ms" "$hop" "$dns_ms" "$dns_source" + if [ "$rc" != 0 ]; then cat "$dir/error" >&2; return "$rc"; fi + code=''; redirect='' + read -r code dns tcp tls first total redirect <"$dir/stats" || true + redirect="${redirect%"$(printf '\r')"}" + case "$code" in + 301|302|303|307|308) + [ -n "$redirect" ] && [ "$hop" -lt 3 ] || return 47 + next_origin="$(remote_url_origin "$redirect")" || return 47 + # Send credentials only within the same origin or to HTTPS on + # the very same host. Never trust arbitrary redirect destinations. + if [ "$origin" != "$next_origin" ]; then + case "$origin|$next_origin" in + http://*'|'https://*) + # Compare hosts independently of the two ports. + target="${next_origin%:*}" + [ "${origin%:*}" = "http://${target#https://}" ] || return 47 + ;; + *) return 47 ;; + esac + fi + url="$redirect"; origin="$next_origin"; hop=$((hop+1)) + ;; + *) [ ! -f "$dir/body" ] || cat "$dir/body"; return 0 ;; + esac + done +) + post_json() ( local url token file url="$1" @@ -827,13 +930,10 @@ post_json() ( fi if command -v curl >/dev/null 2>&1; then - curl -fsSL --location --max-redirs 3 --post301 --post302 --post303 \ - --connect-timeout 4 --max-time 10 --noproxy '*' \ - -H "Authorization: Bearer $token" \ - -H "Content-Type: application/json" \ - --data-binary "@$file" "$url" + remote_curl_post "$url" "$token" "$file" return fi + [ -z "${OWRT_REMOTE_HTTP_METRICS:-}" ] || printf 'tool=uclient/wget DNS_ms=n/a TCP_ms=n/a TLS_ms=n/a\n' >>"$OWRT_REMOTE_HTTP_METRICS" if command -v wget >/dev/null 2>&1; then wget -q -T 10 -O - \ --header="Authorization: Bearer $token" \ @@ -918,6 +1018,7 @@ heartbeat_emit_endpoint() { local base marker base="$(normalize_url_base "$1")" [ -n "$base" ] || return 0 + case "${HEARTBEAT_REQUIRE_HTTPS:-0}|$base" in 1'|'http://*) return 0 ;; esac marker="|$base|" case "${HEARTBEAT_ENDPOINT_SEEN:-}" in *"$marker"*) return 0 ;; @@ -927,11 +1028,13 @@ heartbeat_emit_endpoint() { } heartbeat_candidate_endpoints() { - local hub_url public_url vps_host + local hub_url public_url vps_host HEARTBEAT_REQUIRE_HTTPS HEARTBEAT_ENDPOINT_SEEN='|' hub_url="$(uci_get hub_url '')" public_url="$(uci_get public_url '')" vps_host="$(uci_get vps_host '')" + HEARTBEAT_REQUIRE_HTTPS=0 + case "$hub_url" in https://*) HEARTBEAT_REQUIRE_HTTPS=1 ;; esac heartbeat_emit_endpoint "$hub_url" heartbeat_emit_endpoint "$public_url" case "$vps_host" in @@ -1010,8 +1113,31 @@ heartbeat_apply_hub_update() { fi } -send_heartbeat() { - local hub_url token endpoint tmp response event used fallback_base errors rc +heartbeat_failure_reason() { + case "$1|$2" in + *'|'401|*'|'403) printf auth_rejected ;; + 28'|'*) printf timeout ;; + 5'|'*|6'|'*) printf dns_failed ;; + 7'|'*) printf connect_failed ;; + 35'|'*) printf tls_handshake_failed ;; + 51'|'*|58'|'*|60'|'*|77'|'*) printf tls_verification_failed ;; + 47'|'*) printf redirect_rejected ;; + *'|'408|*'|'429|*'|'500|*'|'502|*'|'503|*'|'504) printf server_temporary ;; + 18'|'*|52'|'*|55'|'*|56'|'*|92'|'*) printf connection_interrupted ;; + 0'|'*) printf invalid_heartbeat_response ;; + *) printf request_failed ;; + esac +} + +heartbeat_diagnostics() { + local state + state="${TMPDIR:-/tmp}/owrt-remote-heartbeat-last" + printf 'Последний Heartbeat (только безопасные поля):\n' + if [ -r "$state" ]; then cat "$state"; else printf 'Замеров пока нет; выполни owrt-remote heartbeat.\n'; fi +} + +send_heartbeat() ( + local hub_url token endpoint tmp response event used fallback_base errors rc dir metrics http attempt max_attempts reason previous previous_reason safe_endpoint elapsed started diagnostic event="${1:-}" hub_url="$(uci_get hub_url '')" token="$(uci_get hub_token '')" @@ -1023,34 +1149,68 @@ send_heartbeat() { wan_reconcile_xray fi - endpoint="${hub_url%/}/api/heartbeat" - tmp="${TMPDIR:-/tmp}/owrt-remote-heartbeat.$$" - response="${TMPDIR:-/tmp}/owrt-remote-heartbeat.response.$$" + dir="$(mktemp -d "${TMPDIR:-/tmp}/owrt-remote-heartbeat.XXXXXX")" || return 1 + chmod 700 "$dir" + trap 'rm -f "$dir/payload" "$dir/response" "$dir/response.error" "$dir/metrics" "$dir/last"; rmdir "$dir" 2>/dev/null || true' EXIT + trap 'exit 1' INT TERM + tmp="$dir/payload"; response="$dir/response" errors="$response.error" + metrics="$dir/metrics" + export OWRT_REMOTE_HTTP_METRICS="$metrics" heartbeat_json "$event" >"$tmp" used=0 + previous=''; previous_reason='' for endpoint in $(heartbeat_candidate_endpoints); do used=1 - rc=0 - post_json "$endpoint" "$token" "$tmp" >"$response" 2>"$errors" || rc=$? - if [ "$rc" = 0 ] && grep -Eq '"ok"[[:space:]]*:[[:space:]]*true' "$response"; then - fallback_base="$(heartbeat_base_from_endpoint "$endpoint")" - if ! heartbeat_apply_hub_update "$response" "$fallback_base"; then - log 'Heartbeat: Hub ответил, но обновление настроек не применилось' - rm -f "$tmp" "$response" "$errors" - return 1 - fi - cat "$response" - log "Heartbeat: OK; Hub=$fallback_base; WAN_direct=$(uci_get wan_direct 0); WAN_active=$(cat "$WAN_STATE/active-interface" 2>/dev/null)" - rm -f "$tmp" "$response" "$errors" - return 0 + safe_endpoint="$(remote_url_origin "$endpoint")" || { log 'Heartbeat: ошибка; reason=invalid_endpoint'; continue; } + if [ -n "$previous" ]; then + log "Heartbeat: fallback; from=$previous; to=$safe_endpoint; reason=$previous_reason; предыдущие попытки исчерпаны" fi - log "Heartbeat: ошибка; endpoint=$endpoint; rc=$rc; $(head -c 1024 "$errors"); ответ=$(head -c 1024 "$response")" + attempt=1; max_attempts=1 + case "$endpoint" in https://*) max_attempts=2 ;; esac + while [ "$attempt" -le "$max_attempts" ]; do + rc=0; : >"$metrics"; started="$(remote_clock_ms)" + post_json "$endpoint" "$token" "$tmp" >"$response" 2>"$errors" || rc=$? + elapsed=$(( $(remote_clock_ms) - started )) + http="$(sed -n 's/.*HTTP=\([0-9][0-9][0-9]\).*/\1/p' "$metrics" | tail -n 1)" + reason="$(heartbeat_failure_reason "$rc" "$http")" + if grep -Fq 'Failed to allocate uclient context' "$errors"; then reason=http_client_context_failed; fi + diagnostic="endpoint=$safe_endpoint; attempt=$attempt/$max_attempts; rc=$rc; reason=$reason; elapsed_ms=$elapsed; $(tail -n 1 "$metrics")" + printf '%s\n' "$diagnostic" >"$dir/last" + mv -f "$dir/last" "${TMPDIR:-/tmp}/owrt-remote-heartbeat-last" + if [ "$rc" = 0 ] && grep -Eq '"ok"[[:space:]]*:[[:space:]]*true' "$response"; then + fallback_base="$(heartbeat_base_from_endpoint "$endpoint")" + if ! heartbeat_apply_hub_update "$response" "$fallback_base"; then + log 'Heartbeat: Hub ответил, но обновление настроек не применилось' + return 1 + fi + # Stable OK messages remain deduplicated by the RAM journal; + # fresh timings are available separately in network-diagnostics. + printf '%s\n' "endpoint=$safe_endpoint; attempt=$attempt/$max_attempts; rc=0; reason=ok; elapsed_ms=$elapsed; $(tail -n 1 "$metrics")" >"$dir/last" + mv -f "$dir/last" "${TMPDIR:-/tmp}/owrt-remote-heartbeat-last" + cat "$response" + log "Heartbeat: OK; Hub=$safe_endpoint; WAN_direct=$(uci_get wan_direct 0); WAN_active=$(cat "$WAN_STATE/active-interface" 2>/dev/null)" + return 0 + fi + # Do not log curl stderr or response bodies: either may echo secrets. + log "Heartbeat: ошибка; $diagnostic" + [ "$reason" != auth_rejected ] || return 1 + case "$reason" in timeout|dns_failed|connect_failed|tls_handshake_failed|server_temporary|connection_interrupted) + if [ "$attempt" -lt "$max_attempts" ]; then + attempt=$((attempt+1)) + log "Heartbeat: retry HTTPS; endpoint=$safe_endpoint; attempt=$attempt/$max_attempts; reason=$reason; delay=1s" + sleep 1 + continue + fi ;; + esac + break + done + previous="$safe_endpoint"; previous_reason="$reason" done - rm -f "$tmp" "$response" "$errors" [ "$used" = "1" ] || die "hub_url/public_url/vps_host пустые" + case "$hub_url" in https://*) log 'Heartbeat: fallback остановлен; reason=https_required; автоматический переход на HTTP отключён' ;; esac return 1 -} +) wan_reconcile_xray() { local config bound device @@ -1417,6 +1577,7 @@ case "$cmd" in ;; network-diagnostics) wan_diagnostics + heartbeat_diagnostics ;; install-xray-tmp) install_xray_tmp @@ -1440,6 +1601,9 @@ case "$cmd" in heartbeat-loop) heartbeat_loop ;; + heartbeat-diagnostics) + heartbeat_diagnostics + ;; logs-sync) sync_global_logs ;; diff --git a/tests/HEARTBEAT_TRANSPORT.md b/tests/HEARTBEAT_TRANSPORT.md new file mode 100644 index 0000000..4a88ca4 --- /dev/null +++ b/tests/HEARTBEAT_TRANSPORT.md @@ -0,0 +1,120 @@ +# Heartbeat: HTTPS, авторизация и диагностика (v116) + +## Разбор сбоя 15.10.2026 + +В прежнем клиенте после первой ошибки HTTPS сразу проверялся следующий +адрес, в том числе автоматически сформированный HTTP. Повторной попытки +того же HTTPS до переключения не было. Настроенный Hub URL при этом +не обязательно менялся: перебор адресов происходил внутри одного цикла. + +Bearer-заголовок в исходном запросе формировался одинаково для всех адресов. +Однако curl с `--location` снимает Authorization при смене origin, включая +HTTP → HTTPS. `--post301` сохраняет POST, но не авторизацию. Это объясняет +цепочку HTTP 301 → HTTPS 401 при правильном токене. Механизм воспроизведён +на локальных HTTP/HTTPS-серверах с настоящим curl и проверкой сертификата. +Заголовки реального nginx в момент исходного сбоя не захватывались, поэтому +совпадение с конкретным историческим запросом остаётся предположением. + +Один `rc=28` и нулевое тело ответа не определяют, на каком этапе был тайм-аут. +Текущие быстрые ответы `/health` не доказывают причину прошедшего сбоя. +HTTP 401 на `/api/heartbeat` без авторизации ожидаем. Интервал примерно +32 секунды совместим с прежним циклом: время запроса плюс пауза 30 секунд. + +Официальное описание curl: https://curl.se/docs/manpage.html + +## Поведение после исправления + +- При временной ошибке HTTPS выполняется одна повторная попытка того же + адреса через секунду: максимум две попытки по 10 секунд на адрес. +- Повторяются тайм-ауты, ошибки DNS/TCP, TLS handshake, обрывы соединения + и временные ответы сервера 408/429/500/502/503/504. Ошибка проверки + сертификата не повторяется автоматически. +- После исчерпания попыток можно перейти к следующему HTTPS-кандидату. + При настроенном HTTPS HTTP-кандидаты исключены, включая порт 8088. + Явно настроенные установки HTTP продолжают работать. +- HTTP 401/403 завершает цикл с `reason=auth_rejected`; перебор адресов + не используется для обхода отказа авторизации. +- curl больше не следует перенаправлениям автоматически. Разрешены + максимум три перехода в пределах origin либо HTTP → HTTPS на том же + хосте. Каждый разрешённый переход повторяет JSON POST с Bearer. + Смена хоста и HTTPS → HTTP отклоняются. Проверка TLS сохранена. +- При прямом WAN интерфейс и `--resolve` рассчитываются для каждого + разрешённого перехода, включая новый HTTPS-порт. Xray и правила + маршрутизации этим исправлением не переписываются. + +## Диагностика и хранение + +`owrt-remote heartbeat-diagnostics` показывает последний результат. +Он также добавлен к `owrt-remote network-diagnostics`. +Снимок атомарно заменяется в `/tmp/owrt-remote-heartbeat-last` — на OpenWrt +это RAM. Временные тела запросов/ответов находятся в приватных каталогах +`/tmp` и удаляются после запроса. Настройки UCI не меняются из-за замеров. + +Поля результата: безопасный origin без пути, query и userinfo, номер +попытки, rc, HTTP, причина, общее время, DNS, TCP, TLS и время до первого +байта. В журнале ошибки содержат эти замеры, переключение — исходный +и следующий origin с причиной. Успешные записи остаются стабильными +для существующего подавления повторов; свежие замеры находятся в снимке. +Сырые stderr curl и тела ответов не записываются в журнал: сервер может +отразить туда секрет. Токен и Authorization в диагностике отсутствуют. + +Все времена в миллисекундах: + +- `DNS_ms` — время разрешения имени curl; при прямом WAN измеряется + отдельный запрос WAN DNS. `DNS_source=cache/pinned/literal` означает, + что DNS-запрос не требовался; `lookup` — запрос выполнялся. +- `TCP_ms` — `time_connect - time_namelookup`. +- `TLS_ms` — `time_appconnect - time_connect`; `incomplete` означает, + что этап не завершился. TCP тоже может быть `incomplete`. +- `TTFB_ms` — от начала запроса curl до первого байта, `total_ms` — + полное время curl. `elapsed_ms` включает подготовку запроса. +- `WAN_resolve_ms` — подготовка WAN-адреса и маршрута; это не чистое + время DNS. При `--resolve` системный DNS curl не используется. +- Для wget/uclient, у которых нет аналогичного write-out, этапы помечены + `n/a`, без выдуманных измерений. + +## Установка и откат из Windows PowerShell + +```powershell +powershell.exe -NoProfile -ExecutionPolicy Bypass -File "C:\Users\k.zolotarev95\Documents\openwrt overlay\vps\deploy-heartbeat-transport-fix.ps1" -Router "root@192.168.2.1" -Action Install +``` + +Обновляются агент и WAN helper. Перезапускается только экземпляр Heartbeat +под procd; Xray и удалённый туннель скрипт не перезапускает. Остановленный +экземпляр остаётся остановленным. Резервная копия первых файлов сохраняется +в `/root/owrt-remote-backup-before-heartbeat-transport-v116`. +Маркер `HEARTBEAT_TRANSPORT_ROUTER_Install_OK` подтверждает установку кода, +а доступность Hub проверяется отдельно: + +```powershell +ssh root@192.168.2.1 'owrt-remote heartbeat >/dev/null; echo HEARTBEAT_RC=$?; owrt-remote heartbeat-diagnostics; logread -e owrt-remote | tail -n 35' +``` + +`HEARTBEAT_RC=0`, `reason=ok` и `HTTP=200` подтверждают успешный запрос. +Для отката: + +```powershell +powershell.exe -NoProfile -ExecutionPolicy Bypass -File "C:\Users\k.zolotarev95\Documents\openwrt overlay\vps\deploy-heartbeat-transport-fix.ps1" -Router "root@192.168.2.1" -Action Rollback +``` + +При неполной/отсутствующей копии откат прекращается до изменения файлов. +При ошибке установки восстанавливаются оба файла текущей попытки. + +## Локальные проверки + +`test_heartbeat_transport.py` проверяет повтор HTTPS, запрет HTTP fallback, +401/403, безопасные поля и замеры DNS/TCP/TLS. Реальные HTTP/HTTPS-серверы +проверяют потерю Bearer в прежнем curl, исправленный переход, запрет чужого +хоста/понижения TLS, относительный redirect, предел redirect и прямой WAN. +Самоподписанный тестовый CA явно доверен только тестовому curl; `-k` нет. + +`test_heartbeat_transport_deploy.py` проверяет повторную установку, исходную +резервную копию, откат, отказы до/после записи и адресный перезапуск только +Heartbeat. Дополнительно выполняются host policy, WAN failover, доставка +журналов, Xray apply и Xray validation. + +Результат локальной проверки 15.10.2026: 14 тестов транспорта и 91 тест +регрессии прошли успешно, без пропусков. В проверках применения настроек +использовался настоящий Xray 26.3.27. PowerShell и POSIX-синтаксис проверены, +пакет подготовки содержит UTF-8 без BOM и окончания строк LF. На реальный +роутер этот локальный фикс автоматически не устанавливался. diff --git a/tests/WAN_DNS.md b/tests/WAN_DNS.md new file mode 100644 index 0000000..203d0f3 --- /dev/null +++ b/tests/WAN_DNS.md @@ -0,0 +1,73 @@ +# WAN IPv4 DNS fallback (local v116 fix) + +`files/usr/lib/owrt-remote/wan.sh` now explicitly queries +`nslookup -type=A -timeout=3 -retry=1 "$host" "$dns"`. +BusyBox's default lookup sends both A and AAAA queries; explicit `-type=A` +and the timeout/retry options are supported by its internal resolver. See +[BusyBox 1.36 nslookup source](https://github.com/mirror/busybox/blob/1_36_stable/networking/nslookup.c) +and [OpenWrt 24.10 BusyBox options](https://github.com/openwrt/openwrt/blob/openwrt-24.10/package/utils/busybox/config/networking/Config.in). + +The parser preserves the nslookup exit status and accepts only a valid IPv4 +answer for the queried name or its CNAME chain after a successful query. +Resolver headers, unrelated names, malformed IPv4, IPv6 answers and +198.18.0.0/15 fake-IP addresses cannot populate the IPv4 cache. Existing +explicit IPv6 literals keep their prior behavior. + +The original cache policy is retained: a successful IPv4 is reused for +5 minutes; on a failed refresh the last successful address remains usable +until its original timestamp is 1 hour old. Failed refreshes do not extend +that timestamp. Corrupt timestamps, future timestamps and invalid cached +addresses are rejected. The cache remains under `/tmp/owrt-remote-wan`. + +Failure diagnostics distinguish `reason=timeout`, `reason=no_a_record`, +`reason=parse_error`, `reason=resolver_error` and `reason=rejected_address`. +They include the domain, selected resolver and original exit status, without +raw DNS output. A successful A answer emits no `WAN DNS unavailable` warning. +WAN/DNS selection, Podkop, Xray and route/policy-rule implementations are +unchanged by this fix. + +## Verification + +```powershell +$env:PYTHONPATH = 'tests' +python -m unittest test_wan_dns test_wan_dns_deploy -v +# Optional second run with actual BusyBox ash and built-in awk: +$env:OWRT_TEST_BUSYBOX = 'C:\path\to\busybox64.exe' +python -m unittest test_wan_dns test_wan_dns_deploy -v +``` + +22 tests cover A-only arguments for both reported resolvers, BusyBox answer +formats, CNAME chains, DNS errors, validation, cache bounds, syntax, repeated +installation, exact rollback and recovery after installation failures. +The BusyBox ash run uses busybox-w32 1.38.0-FRP-6075 and its built-in applets, +with fixture nslookup replies. The executable is obtained from the +[maintainer](https://frippery.org/busybox/) and checked against its SHA256SUM. +This is not a live OpenWrt DNS/network test; OpenWrt 24.10 option compatibility +is additionally checked against the linked BusyBox sources. + +## Local installation and rollback + +`vps/deploy-wan-dns-fix.ps1` extracts only the DNS functions from the local +source and replaces the corresponding block in the router's existing +`wan.sh`. Everything before and after that block is preserved, including +differences between the published agent and the previous local heartbeat +transport fix. The agent itself is not replaced. + +```powershell +powershell.exe -NoProfile -ExecutionPolicy Bypass -File "C:\Users\k.zolotarev95\Documents\openwrt overlay\vps\deploy-wan-dns-fix.ps1" -Router "root@192.168.2.1" -Action Install +``` + +The installer saves the first backup at +`/root/owrt-remote-backup-before-wan-dns-v116/wan.sh`, checks shell syntax and +reloads only the supervised heartbeat instance so it reads the new helper. +It does not restart Xray or regenerate configuration/routing. Installation +verification/reload failures restore the file from that attempt. + +```powershell +powershell.exe -NoProfile -ExecutionPolicy Bypass -File "C:\Users\k.zolotarev95\Documents\openwrt overlay\vps\deploy-wan-dns-fix.ps1" -Router "root@192.168.2.1" -Action Rollback +``` + +Rollback restores the entire saved `wan.sh`; use it before installing later +changes to that file. No service is started if heartbeat was already stopped. +All uploads use UTF-8 without BOM and LF. `-PrepareOnly` creates local payloads +for inspection without contacting the router. diff --git a/tests/test_heartbeat_transport.py b/tests/test_heartbeat_transport.py new file mode 100644 index 0000000..c87fb97 --- /dev/null +++ b/tests/test_heartbeat_transport.py @@ -0,0 +1,288 @@ +"""HTTPS retry policy, origin-scoped auth, timings and real curl redirects.""" +from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer +import json +import os +from pathlib import Path +import shutil +import ssl +import subprocess +import threading +import unittest + +import test_host_policy as shell_tests + +ROOT, SH = shell_tests.ROOT, shell_tests.SH + + +@unittest.skipUnless(SH, "POSIX shell required") +class HeartbeatTransportTests(unittest.TestCase): + setUp = shell_tests.RouterShellTests.setUp + config = shell_tests.RouterShellTests.config + run_shell = shell_tests.RouterShellTests.run_shell + + def policy(self, commands, **env): + self.config(hub_url="https://primary.example", public_url="https://backup.example", + vps_host="192.0.2.7", hub_token="never-log-this-token") + self.directory.joinpath("calls").write_text("") + return self.run_shell(r''' +heartbeat_json() { printf '{"id":"test-router"}'; } +sleep() { printf 'sleep %s\n' "$*" >>"$TEST_ROOT/calls"; } +''' + commands, **env) + + def test_one_timeout_retries_https_without_http_or_setting_changes(self): + result = self.policy(r''' +post_json() { + printf '%s\n' "$1" >>"$TEST_ROOT/calls" + if [ ! -f "$TEST_ROOT/tried" ]; then touch "$TEST_ROOT/tried"; return 28; fi + printf '{"ok":true}' +} +send_heartbeat >/dev/null +''') + self.assertEqual(result.returncode, 0, result.stderr) + self.assertEqual(self.directory.joinpath("calls").read_text().splitlines(), + ["https://primary.example/api/heartbeat", "sleep 1", "https://primary.example/api/heartbeat"]) + self.assertIn("retry HTTPS", result.stderr) + self.assertNotIn("fallback;", result.stderr) + self.assertNotIn("never-log-this-token", result.stderr) + self.assertFalse(self.directory.joinpath("commits").exists()) + self.assertEqual(self.directory.joinpath("owrt-remote-heartbeat-last").read_text().split("reason=")[1].split(";")[0], "ok") + + def test_exhausted_https_uses_secure_backup_and_explains_reason(self): + result = self.policy(r''' +post_json() { + printf '%s\n' "$1" >>"$TEST_ROOT/calls" + case "$1" in https://backup.example/*) printf '{"ok":true}' ;; *) return 28 ;; esac +} +send_heartbeat >/dev/null +''') + self.assertEqual(result.returncode, 0, result.stderr) + calls = self.directory.joinpath("calls").read_text() + self.assertEqual(calls.count("https://primary.example/api/heartbeat"), 2) + self.assertIn("https://backup.example/api/heartbeat", calls) + self.assertNotIn("http://", calls) + self.assertIn("fallback; from=https://primary.example:443; to=https://backup.example:443; reason=timeout", result.stderr) + + def test_https_never_uses_plain_http_even_after_all_retries(self): + result = self.policy(r''' +post_json() { printf '%s\n' "$1" >>"$TEST_ROOT/calls"; return 28; } +send_heartbeat +''') + self.assertEqual(result.returncode, 1, result.stderr) + self.assertNotIn("http://", self.directory.joinpath("calls").read_text()) + self.assertIn("reason=https_required", result.stderr) + + def test_401_does_not_retry_or_change_endpoint_and_never_logs_echoed_secrets(self): + result = self.policy(r''' +post_json() { + printf '%s\n' "$1" >>"$TEST_ROOT/calls" + printf 'tool=curl HTTP=401 DNS_ms=1 TCP_ms=2 TLS_ms=3\n' >"$OWRT_REMOTE_HTTP_METRICS" + printf 'Authorization: Bearer never-log-this-token\n' >&2 + printf '{"hub_token":"never-log-this-token"}' + return 22 +} +send_heartbeat +''') + self.assertEqual(result.returncode, 1, result.stderr) + self.assertEqual(self.directory.joinpath("calls").read_text().splitlines(), ["https://primary.example/api/heartbeat"]) + self.assertIn("reason=auth_rejected", result.stderr) + self.assertIn("HTTP=401", result.stderr) + self.assertNotIn("never-log-this-token", result.stdout + result.stderr) + + def test_http_only_configuration_still_works_and_origin_removes_secrets(self): + self.config(hub_url="http://plain.example:8088", public_url="http://plain.example:8088", hub_token="test-token") + result = self.run_shell(r''' +heartbeat_json() { printf '{}'; } +post_json() { printf '{"ok":true}'; } +send_heartbeat >/dev/null +remote_url_origin 'https://hub.example/path?token=secret#secret' +''') + self.assertEqual(result.returncode, 0, result.stderr) + self.assertEqual(result.stdout, "https://hub.example:443") + self.assertNotIn("secret", result.stderr) + + def test_certificate_error_is_not_retried_and_never_uses_http(self): + result = self.policy(r''' +post_json() { printf '%s\n' "$1" >>"$TEST_ROOT/calls"; return 60; } +send_heartbeat +''') + self.assertEqual(result.returncode, 1, result.stderr) + calls = self.directory.joinpath("calls").read_text() + self.assertEqual(calls.count("https://primary.example/api/heartbeat"), 1) + self.assertNotIn("sleep", calls) + self.assertNotIn("http://", calls) + self.assertIn("reason=tls_verification_failed", result.stderr) + + def test_timing_deltas_and_safe_fields_only(self): + self.directory.joinpath("stats").write_text("200 0.010 0.030 0.080 0.100 0.120 https://evil.example/?token=secret\n") + result = self.run_shell(r''' +OWRT_REMOTE_HTTP_METRICS="$TEST_ROOT/metrics" +remote_curl_metrics "$TEST_ROOT/stats" https 15 1 +cat "$TEST_ROOT/metrics" +''') + self.assertEqual(result.returncode, 0, result.stderr) + self.assertIn("DNS_ms=10.0 TCP_ms=20.0 TLS_ms=50.0", result.stdout) + self.assertIn("WAN_resolve_ms=15 hop=1", result.stdout) + self.assertNotIn("secret", result.stdout) + self.assertNotIn("evil", result.stdout) + + def test_wan_dns_timing_distinguishes_lookup_cache_and_pinned_host(self): + self.config(vps_host="hub.example", vps_host_mode="manual") + self.directory.joinpath("stats").write_text("200 0.000 0.030 0.080 0.100 0.120\n") + result = self.run_shell(r''' +OWRT_REMOTE_HTTP_METRICS="$TEST_ROOT/metrics" +OWRT_REMOTE_DNS_METRICS="$TEST_ROOT/dns-time" +wan_resolve_host hub.example >/dev/null || exit +read -r duration source <"$TEST_ROOT/dns-time" +[ "$source" = lookup ] || exit 81 +wan_resolve_host hub.example >/dev/null || exit +read -r duration source <"$TEST_ROOT/dns-time" +[ "$duration $source" = '0 cache' ] || exit 82 +remote_curl_metrics "$TEST_ROOT/stats" https 15 0 "$duration" "$source" +uci set owrtremote.main.vps_host=192.0.2.1 +wan_endpoint_ip https://hub.example/api/heartbeat >/dev/null || exit +read -r duration source <"$TEST_ROOT/dns-time" +[ "$duration $source" = '0 pinned' ] || exit 83 +remote_curl_metrics "$TEST_ROOT/stats" https 15 0 "$duration" "$source" +cat "$TEST_ROOT/metrics" +''') + self.assertEqual(result.returncode, 0, result.stderr) + self.assertIn("DNS_ms=0.0", result.stdout) + self.assertIn("DNS_source=cache", result.stdout) + self.assertIn("DNS_source=pinned", result.stdout) + + +@unittest.skipUnless(SH, "POSIX shell required") +class CurlRedirectTests(unittest.TestCase): + setUp = shell_tests.RouterShellTests.setUp + config = shell_tests.RouterShellTests.config + run_shell = shell_tests.RouterShellTests.run_shell + + def prepare(self, secure_front=False): + if os.name == "nt": + bindir = Path(os.environ.get("ProgramFiles", "C:/Program Files")) / "Git/mingw64/bin" + self.curl = bindir / "curl.exe" + openssl = bindir / "openssl.exe" + else: + self.curl = Path(shutil.which("curl") or "/nonexistent") + openssl = Path(shutil.which("openssl") or "/nonexistent") + if not self.curl.exists() or not openssl.exists(): + self.skipTest("real curl and OpenSSL required") + cert = self.directory / "cert.pem" + key = self.directory / "key.pem" + subprocess.run([str(openssl), "req", "-x509", "-newkey", "rsa:2048", "-nodes", "-days", "1", + "-subj", "/CN=localhost", "-addext", "subjectAltName=DNS:localhost,IP:127.0.0.1", + "-keyout", str(key), "-out", str(cert)], check=True, capture_output=True) + self.env.update(TEST_CURL=self.curl.as_posix(), TEST_CA_CERT=cert.as_posix()) + self.directory.joinpath("payload").write_bytes(b'{"id":"test-router"}') + self.config(wan_direct="0") + self.records = [] + + owner = self + + class Handler(BaseHTTPRequestHandler): + def log_message(self, *args): + pass + + def do_POST(self): + body = self.rfile.read(int(self.headers.get("Content-Length", 0))) + owner.records.append((self.server.server_port, self.path, self.headers.get("Authorization"), body)) + if self.server is owner.front and self.path == "/api/heartbeat": + self.send_response(owner.redirect_code) + self.send_header("Location", owner.destination) + response = b"" + else: + self.send_response(200 if self.headers.get("Authorization") == "Bearer test-token" else 401) + response = b'{"ok":true}' + self.send_header("Content-Length", str(len(response))) + self.end_headers() + self.wfile.write(response) + + context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER) + context.load_cert_chain(cert, key) + self.back = ThreadingHTTPServer(("127.0.0.1", 0), Handler) + self.back.socket = context.wrap_socket(self.back.socket, server_side=True) + self.front = ThreadingHTTPServer(("127.0.0.1", 0), Handler) + if secure_front: + self.front.socket = context.wrap_socket(self.front.socket, server_side=True) + for server in (self.front, self.back): + thread = threading.Thread(target=server.serve_forever, daemon=True) + thread.start() + self.addCleanup(server.server_close) + self.addCleanup(server.shutdown) + self.redirect_code = 301 + self.destination = f"https://localhost:{self.back.server_port}/api/heartbeat" + self.url = f"{'https' if secure_front else 'http'}://localhost:{self.front.server_port}/api/heartbeat" + # shell_tests supplies a mock curl; replace only the executable binding. + self.real = r''' +curl() { "$TEST_CURL" -q --cacert "$TEST_CA_CERT" "$@"; } +OWRT_REMOTE_HTTP_METRICS="$TEST_ROOT/metrics" +export OWRT_REMOTE_HTTP_METRICS +''' + + def test_real_curl_reproduces_401_then_upgrade_keeps_json_and_auth(self): + self.prepare() + old = subprocess.run([str(self.curl), "-q", "--cacert", self.env["TEST_CA_CERT"], "-fsSL", "--noproxy", "*", "--max-time", "5", + "--post301", "-H", "Authorization: Bearer test-token", "-H", "Content-Type: application/json", + "--data-binary", "@" + str(self.directory / "payload"), self.url], + env=self.env, capture_output=True) + self.assertEqual(old.returncode, 22, old.stderr) + self.assertEqual(self.records[-1][2], None, "curl drops auth across HTTP -> HTTPS") + self.records.clear() + result = self.run_shell(self.real + 'post_json "$TEST_URL" test-token "$TEST_ROOT/payload"', TEST_URL=self.url) + self.assertEqual(result.returncode, 0, result.stderr) + self.assertTrue(json.loads(result.stdout)["ok"]) + self.assertEqual([x[2] for x in self.records], ["Bearer test-token"] * 2) + self.assertTrue(all(x[3] == b'{"id":"test-router"}' for x in self.records)) + self.assertEqual(len(self.directory.joinpath("metrics").read_text().splitlines()), 2) + self.assertFalse(list(self.directory.glob("owrt-remote-http.*"))) + + def test_rejects_cross_host_without_forwarding_token(self): + self.prepare() + self.destination = f"https://127.0.0.1:{self.back.server_port}/api/heartbeat?token=secret" + result = self.run_shell(self.real + 'post_json "$TEST_URL" test-token "$TEST_ROOT/payload"', TEST_URL=self.url) + self.assertEqual(result.returncode, 47, result.stderr) + self.assertEqual(len(self.records), 1) + self.assertNotIn("secret", self.directory.joinpath("metrics").read_text()) + + def test_rejects_tls_downgrade_without_forwarding_token(self): + self.prepare(secure_front=True) + self.destination = self.url.replace("https://", "http://") + result = self.run_shell(self.real + 'post_json "$TEST_URL" test-token "$TEST_ROOT/payload"', TEST_URL=self.url) + self.assertEqual(result.returncode, 47, result.stderr) + self.assertEqual(len(self.records), 1) + + def test_same_origin_relative_redirect_preserves_auth_and_post(self): + self.prepare(secure_front=True) + self.destination = "/redirected" + self.redirect_code = 307 + result = self.run_shell(self.real + 'post_json "$TEST_URL" test-token "$TEST_ROOT/payload"', TEST_URL=self.url) + self.assertEqual(result.returncode, 0, result.stderr) + self.assertTrue(json.loads(result.stdout)["ok"]) + self.assertEqual([x[1] for x in self.records], ["/api/heartbeat", "/redirected"]) + self.assertEqual([x[2] for x in self.records], ["Bearer test-token"] * 2) + + def test_repeated_redirects_are_bounded(self): + self.prepare() + self.destination = self.url + result = self.run_shell(self.real + 'post_json "$TEST_URL" test-token "$TEST_ROOT/payload"', TEST_URL=self.url) + self.assertEqual(result.returncode, 47, result.stderr) + self.assertEqual(len(self.records), 4) + + def test_wan_redirect_resolves_and_binds_both_hops(self): + self.prepare() + result = self.run_shell(self.real + r''' +wan_http_target() { + local port + printf '%s\n' "$1" >>"$TEST_ROOT/targets" + port="${1#*localhost:}"; port="${port%%/*}" + printf '127.0.0.1|localhost:%s:127.0.0.1' "$port" +} +wan_post_json "$TEST_URL" test-token "$TEST_ROOT/payload" +''', TEST_URL=self.url) + self.assertEqual(result.returncode, 0, result.stderr) + self.assertEqual(self.directory.joinpath("targets").read_text().splitlines(), [self.url, self.destination]) + self.assertEqual([x[2] for x in self.records], ["Bearer test-token"] * 2) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_heartbeat_transport_deploy.py b/tests/test_heartbeat_transport_deploy.py new file mode 100644 index 0000000..7ca7ed7 --- /dev/null +++ b/tests/test_heartbeat_transport_deploy.py @@ -0,0 +1,122 @@ +"""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 HeartbeatTransportDeploymentTests(unittest.TestCase): + def setUp(self): + self.temp = tempfile.TemporaryDirectory(prefix="heartbeat-transport-deploy-") + self.addCleanup(self.temp.cleanup) + self.root = Path(self.temp.name) + self.targets = {"wan.sh": self.root / "wan.sh", "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-heartbeat-transport-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-heartbeat-transport-v116", + "backup_dir=" + shlex.quote(self.backup.as_posix())) + self.script = self.script.replace("printf /usr/lib/owrt-remote/wan.sh", "printf %s " + shlex.quote(self.targets["wan.sh"].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, fail_signal=False, stopped=False): + stage = self.root / "stage" + stage.mkdir() + for item, source in {"wan.sh": "files/usr/lib/owrt-remote/wan.sh", "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") + mocks = r''' + +ubus() { + printf '%s\n' "$*" >>"$TEST_ROOT/ubus-calls" + if [ "$3" = signal ]; then + [ "${TEST_SIGNAL_FAIL:-0}" = 0 ] || return 1 + printf 202 >"$TEST_ROOT/pid" + fi + printf '{}' +} +jsonfilter() { cat >/dev/null; cat "$TEST_ROOT/pid"; } +sleep() { :; } +''' + self.root.joinpath("pid").write_text("" if stopped else "101") + result = subprocess.run([SH], input=mocks + script, encoding="utf-8", capture_output=True, + env={**self.env, "TEST_ROOT": self.root.as_posix(), "TEST_SIGNAL_FAIL": "1" if fail_signal else "0"}, 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("HEARTBEAT_TRANSPORT_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_paired_files_unchanged(self): + for item in ("agent", "wan.sh"): + 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_reloads_only_heartbeat_without_touching_xray(self): + result = self.deploy("Install") + self.assertEqual(result.returncode, 0, result.stderr) + calls = self.root.joinpath("ubus-calls").read_text() + self.assertIn('service signal {"name":"owrt-remote","instance":"heartbeat","signal":9}', calls) + self.assertNotIn('"instance":"xray"', calls) + self.assertIn('Heartbeat loop reloaded', result.stdout) + + def test_stopped_loop_stays_stopped(self): + result = self.deploy("Install", stopped=True) + self.assertEqual(result.returncode, 0, result.stderr) + self.assertNotIn('service signal', self.root.joinpath("ubus-calls").read_text()) + self.assertIn('Heartbeat loop is stopped', result.stdout) + + def test_failed_loop_reload_restores_paired_files_and_reports_failure(self): + result = self.deploy("Install", fail_signal=True) + self.assertNotEqual(result.returncode, 0) + self.assertIn('Failed during heartbeat-reload', result.stderr) + self.assertNotIn('HEARTBEAT_TRANSPORT_ROUTER_Install_OK', result.stdout) + for item, path in self.targets.items(): + self.assertEqual(path.read_bytes(), self.original[item]) + + def test_verify_failure_restores_paired_files(self): + result = self.deploy("Install", fail_verify=True) + self.assertNotEqual(result.returncode, 0) + self.assertIn("Restoring the agent and WAN helper", 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/tests/test_host_policy.py b/tests/test_host_policy.py index 1abba67..1d096f4 100644 --- a/tests/test_host_policy.py +++ b/tests/test_host_policy.py @@ -310,12 +310,12 @@ printf '%s|%s|%s' "$(uci_get hub_url '')" "$(uci_get public_url '')" "$(uci_get self.assertEqual(log.count("reason=https-downgrade"), 2, "repeated proposals must not flood the log") def test_successful_fallback_heartbeat_does_not_replace_configured_hub_url(self): - self.config(hub_url="https://hub.example", hub_token="test-token", vps_host="193.233.82.38") + self.config(hub_url="https://hub.example", public_url="https://backup.example", hub_token="test-token", vps_host="193.233.82.38") result = self.run_shell(''' heartbeat_json() { printf '{"id":"test-router"}'; } post_json() { case "$1" in - http://193.233.82.38:8088/api/heartbeat) printf '{"ok":true}' ;; + https://backup.example/api/heartbeat) printf '{"ok":true}' ;; *) return 1 ;; esac } @@ -428,11 +428,11 @@ printf '%s' "$(uci_get hub_url '')" self.assertIn("", args) self.assertIn("", args) self.assertNotIn("<-k>", args) - self.assertIn("<--max-time>\n<10>", args) - self.assertIn("<--location>", args) - self.assertIn("<--post301>", args) - self.assertIn("<--post302>", args) - self.assertIn("<--post303>", args) + self.assertIn("<--max-time>", args) + self.assertIn("<--resolve>", args) + self.assertIn("<--data-binary>", args) + self.assertNotIn("<--location-trusted>", args) + self.assertNotIn("<--location>", 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="11111111-1111-4111-8111-111111111111") @@ -487,7 +487,7 @@ wan_prepare self.assertEqual(result.returncode, 0, result.stderr) self.assertEqual(self.directory.joinpath("xray-called").read_text().strip(), 'run -config ' + config.as_posix()) - def test_plain_http_heartbeat_accepts_json_after_redirect_follow(self): + def test_plain_http_heartbeat_uses_controlled_authenticated_posts(self): self.config(vps_host="193.233.82.38", vps_host_mode="manual") result = self.run_shell(''' curl() { @@ -498,8 +498,9 @@ post_json http://hub.example/api/heartbeat test-token "$TEST_ROOT/payload" ''') self.assertEqual(result.returncode, 0, result.stderr) args = (self.directory / "curl").read_text() - self.assertIn("<--location>", args) - self.assertIn("<--post301>", args) + self.assertIn("", args) + self.assertIn("<--data-binary>", args) + self.assertNotIn("<--location>", args) def test_literal_ip_fallback_is_not_rewritten_to_a_different_pin(self): self.config(vps_host="193.233.82.38", vps_host_mode="manual") diff --git a/tests/test_router_log_transport.py b/tests/test_router_log_transport.py index 9a6e19e..7ca9008 100644 --- a/tests/test_router_log_transport.py +++ b/tests/test_router_log_transport.py @@ -34,14 +34,18 @@ wan_prepare() { echo prepare >>"$TEST_ROOT/requests"; [ "${TEST_WAN_FAIL:-0}" != xray_running() { [ "${TEST_XRAY_RUNNING:-0}" = 1 ]; } wan_post_json() { echo direct >>"$TEST_ROOT/requests"; fake_post "$1" "$3"; } curl() { - local file arg next url - next=0; file='' + local file arg next url output + next=''; file=''; output='' for arg in "$@"; do - [ "$next" != 1 ] || { file="${arg#@}"; next=0; } - [ "$arg" != --data-binary ] || next=1 + case "$next" in + data) file="${arg#@}"; next=''; continue ;; + output) output="$arg"; next=''; continue ;; + esac + case "$arg" in --data-binary) next=data ;; -o) next=output ;; esac url="$arg" done - fake_post "$url" "$file" + fake_post "$url" "$file" >"$output" || return $? + printf '200 0.001 0.002 0.003 0.004 0.005\n' } fake_post() { echo "$1" >>"$TEST_ROOT/requests" diff --git a/tests/test_wan_dns.py b/tests/test_wan_dns.py new file mode 100644 index 0000000..05a64df --- /dev/null +++ b/tests/test_wan_dns.py @@ -0,0 +1,219 @@ +"""WAN A-record parsing and bounded fallback; no router/network mutations. + +Set OWRT_TEST_BUSYBOX to a BusyBox executable to run this exact suite in ash +with its built-in awk/grep/date applets (busybox-w32 is supported). +""" +import os +from pathlib import Path +import shutil +import subprocess +import tempfile +import unittest + +ROOT = Path(__file__).resolve().parents[1] +BUSYBOX = os.environ.get("OWRT_TEST_BUSYBOX") +SH = shutil.which("sh") +if not SH and os.name == "nt": + candidate = Path(os.environ.get("ProgramFiles", "C:/Program Files")) / "Git/usr/bin/sh.exe" + SH = str(candidate) if candidate.exists() else None + +HEADER = "Server:\t\t8.8.8.8\nAddress:\t8.8.8.8:53\n\n" +GOOD = HEADER + "Non-authoritative answer:\nName:\tbronsvn.developer.li\nAddress: 132.243.19.232\n" +MOCKS = r''' +safe_id() { printf '%s' "$1"; } +wan_dns_server() { printf '%s' "${TEST_DNS:-8.8.8.8}"; } +log() { printf '%s\n' "$*" >&2; } +date() { printf 1800000000; } +remote_clock_ms() { printf 1000; } +nslookup() { + printf '%s\n' "$*" >>"$TEST_ROOT/queries" + cat "$TEST_ROOT/reply" + cat "$TEST_ROOT/reply-stderr" >&2 + return "${TEST_RC:-0}" +} +# Resolution must not change network state or use another resolver. +ip() { printf forbidden-ip >&2; exit 90; } +nft() { printf forbidden-nft >&2; exit 91; } +uci() { printf forbidden-uci >&2; exit 92; } +''' + + +@unittest.skipUnless(BUSYBOX or SH, "POSIX shell required") +class WanDnsTests(unittest.TestCase): + def setUp(self): + self.temp = tempfile.TemporaryDirectory(prefix="wan-dns-") + self.addCleanup(self.temp.cleanup) + self.root = Path(self.temp.name) + self.state = self.root / "state" + self.state.mkdir() + self.cache = self.state / "resolve-bronsvn.developer.li-8.8.8.8" + self.source = (ROOT / "files/usr/lib/owrt-remote/wan.sh").read_text(encoding="utf-8") + + def run_shell(self, reply=GOOD, rc=0, stderr="", commands="wan_resolve_host bronsvn.developer.li", **env): + self.root.joinpath("reply").write_text(reply, encoding="utf-8", newline="\n") + self.root.joinpath("reply-stderr").write_text(stderr, encoding="utf-8", newline="\n") + script = self.root / "run.sh" + script.write_text(self.source + '\nWAN_STATE="$TEST_ROOT/state"\n' + MOCKS + "\n" + commands + "\n", + encoding="utf-8", newline="\n") + args = [BUSYBOX, "ash"] if BUSYBOX else [SH] + process_env = dict(os.environ) + if not BUSYBOX and os.name == "nt": + process_env["PATH"] = str(Path(SH).parent) + os.pathsep + process_env["PATH"] + return subprocess.run(args + [script.as_posix()], capture_output=True, encoding="utf-8", + env={**process_env, "TEST_ROOT": self.root.as_posix(), "TEST_RC": str(rc), **env}, timeout=15) + + def save_cache(self, timestamp=1799999699, ip="132.243.19.231"): + self.cache.write_text(f"{timestamp} {ip}\n", encoding="ascii", newline="\n") + + def test_explicit_a_query_for_both_reported_resolvers_and_no_false_warning(self): + for dns in ("8.8.8.8", "8.8.4.4"): + with self.subTest(dns=dns): + result = self.run_shell(TEST_DNS=dns) + self.assertEqual(result.returncode, 0, result.stderr) + self.assertEqual(result.stdout, "132.243.19.232") + self.assertEqual(result.stderr, "") + self.assertEqual(self.root.joinpath("queries").read_text().splitlines(), + [f"-type=A -timeout=3 -retry=1 bronsvn.developer.li {dns}" for dns in ("8.8.8.8", "8.8.4.4")]) + + def test_busybox_and_numbered_address_formats(self): + for address in ("Address: 132.243.19.232", "Address 1: 132.243.19.232", "Address 1: 132.243.19.232 bronsvn.developer.li"): + with self.subTest(address=address): + self.cache.unlink(missing_ok=True) + result = self.run_shell(HEADER + "Name: bronsvn.developer.li\n" + address + "\n") + self.assertEqual(result.returncode, 0, result.stderr) + self.assertEqual(result.stdout, "132.243.19.232") + + def test_cname_chain_case_and_trailing_dot(self): + reply = HEADER + "BrOnSvN.Developer.Li. canonical name = edge.example.\nedge.example canonical name = origin.example.\nName: origin.example\nAddress: 132.243.19.232\n" + result = self.run_shell(reply) + self.assertEqual(result.returncode, 0, result.stderr) + self.assertEqual(result.stdout, "132.243.19.232") + + def test_host_containing_diagnostic_words_is_not_an_error(self): + host = "timeout-servfail-refused.example" + result = self.run_shell(GOOD.replace("bronsvn.developer.li", host), + commands="wan_resolve_host " + host) + self.assertEqual(result.returncode, 0, result.stderr) + self.assertEqual(result.stdout, "132.243.19.232") + self.assertEqual(result.stderr, "") + + def test_unrelated_name_and_unscoped_address_are_not_answers(self): + for reply in (HEADER + "Address: 132.243.19.232\n", HEADER + "Name: other.example\nAddress: 132.243.19.232\n"): + with self.subTest(reply=reply): + result = self.run_shell(reply) + self.assertNotEqual(result.returncode, 0) + self.assertEqual(result.stdout, "") + self.assertFalse(self.cache.exists()) + + def test_no_a_record_is_distinct_from_timeout_and_parse_error(self): + replies = ((HEADER, 0), + (HEADER + "Non-authoritative answer:\n", 0), + (HEADER + "*** Can't find bronsvn.developer.li: No answer\n", 0), + (HEADER + "** server can't find bronsvn.developer.li: NXDOMAIN\n", 1), + (HEADER + "Name: bronsvn.developer.li\nAddress: 2001:db8::1\n", 0)) + for reply, rc in replies: + with self.subTest(reply=reply): + result = self.run_shell(reply, rc) + self.assertNotEqual(result.returncode, 0) + self.assertEqual(result.stdout, "") + self.assertIn("reason=no_a_record", result.stderr) + + def test_dns_timeout_stderr_and_original_return_code_are_preserved(self): + result = self.run_shell("", 1, ";; connection timed out; no servers could be reached\n") + self.assertNotEqual(result.returncode, 0) + self.assertIn("reason=timeout rc=1", result.stderr) + + def test_malformed_empty_and_invalid_ipv4_are_parse_errors(self): + for reply in ("", "unexpected output\n", HEADER + "*** Can't find bronsvn.developer.li: Parse error\n", + *(HEADER + f"Name: bronsvn.developer.li\nAddress: {ip}\n" for ip in + ("999.243.19.232", "132.243.19", "132.243.19.232.evil", "0132.243.19.232", "", "-1.2.3.4"))): + with self.subTest(reply=reply): + result = self.run_shell(reply) + self.assertNotEqual(result.returncode, 0) + self.assertEqual(result.stdout, "") + self.assertIn("reason=parse_error", result.stderr) + + def test_nonzero_nslookup_is_not_success_even_with_valid_looking_answer(self): + result = self.run_shell(GOOD, 1) + self.assertNotEqual(result.returncode, 0) + self.assertEqual(result.stdout, "") + self.assertIn("reason=resolver_error", result.stderr) + self.assertFalse(self.cache.exists()) + + def test_servfail_is_resolver_error(self): + result = self.run_shell(HEADER + "** server can't find bronsvn.developer.li: SERVFAIL\n", 1) + self.assertNotEqual(result.returncode, 0) + self.assertIn("reason=resolver_error", result.stderr) + + def test_fake_ip_is_rejected_and_later_valid_a_is_used(self): + for ip in ("198.18.0.1", "198.19.255.255"): + result = self.run_shell(GOOD.replace("132.243.19.232", ip)) + self.assertNotEqual(result.returncode, 0) + self.assertIn("reason=rejected_address", result.stderr) + result = self.run_shell(GOOD.replace("132.243.19.232", "198.18.0.1") + "Address: 132.243.19.232\n") + self.assertEqual(result.returncode, 0, result.stderr) + self.assertEqual(result.stdout, "132.243.19.232") + self.assertEqual(result.stderr, "") + + def test_success_refreshes_stale_cache_without_warning(self): + self.save_cache() + result = self.run_shell() + self.assertEqual(result.returncode, 0, result.stderr) + self.assertEqual(result.stderr, "") + self.assertEqual(self.cache.read_text(), "1800000000 132.243.19.232\n") + + def test_recent_valid_cache_skips_lookup(self): + self.save_cache(1799999701) + result = self.run_shell("", 1) + self.assertEqual(result.returncode, 0, result.stderr) + self.assertEqual(result.stdout, "132.243.19.231") + self.assertFalse(self.root.joinpath("queries").exists()) + + def test_last_success_fallback_preserves_age_and_logs_exact_failure(self): + for reply, rc, reason in ((";; connection timed out\n", 1, "timeout"), + (HEADER, 0, "no_a_record"), ("broken reply", 0, "parse_error")): + with self.subTest(reason=reason): + self.save_cache(1799996401) + before = self.cache.read_bytes() + result = self.run_shell(reply, rc) + self.assertEqual(result.returncode, 0, result.stderr) + self.assertEqual(result.stdout, "132.243.19.231") + self.assertIn("WAN DNS unavailable", result.stderr) + self.assertIn("reason=" + reason, result.stderr) + self.assertEqual(self.cache.read_bytes(), before) + + def test_expired_corrupt_future_and_ipv6_cache_are_never_fallback(self): + for timestamp, ip in ((1799996400, "132.243.19.231"), (1800000001, "132.243.19.231"), + ("invalid", "132.243.19.231"), ("08", "132.243.19.231"), + ("999999999999999999999999", "132.243.19.231"), + (1799999999, "2001:db8::1"), (1799999999, "999.1.1.1"), + (1799999999, "198.18.0.1"), (1799999999, "198.19.255.255")): + with self.subTest(timestamp=timestamp, ip=ip): + self.save_cache(timestamp, ip) + result = self.run_shell(HEADER, 0) + self.assertNotEqual(result.returncode, 0) + self.assertEqual(result.stdout, "") + self.assertIn("reason=no_a_record", result.stderr) + + def test_cache_metrics_still_distinguish_actual_lookup(self): + result = self.run_shell(commands=r''' +OWRT_REMOTE_DNS_METRICS="$TEST_ROOT/metrics" +wan_resolve_host bronsvn.developer.li || exit +cat "$TEST_ROOT/metrics" +wan_resolve_host bronsvn.developer.li || exit +cat "$TEST_ROOT/metrics" +''') + self.assertEqual(result.returncode, 0, result.stderr) + self.assertIn("0 lookup", result.stdout) + self.assertIn("0 cache", result.stdout) + + def test_shell_syntax(self): + script = self.root / "wan.sh" + script.write_text(self.source, encoding="utf-8", newline="\n") + args = [BUSYBOX, "ash"] if BUSYBOX else [SH] + result = subprocess.run(args + ["-n", script.as_posix()], capture_output=True, timeout=15) + self.assertEqual(result.returncode, 0, result.stderr) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_wan_dns_deploy.py b/tests/test_wan_dns_deploy.py new file mode 100644 index 0000000..8bc6bb9 --- /dev/null +++ b/tests/test_wan_dns_deploy.py @@ -0,0 +1,129 @@ +"""Install/rollback DNS functions while preserving every other WAN function.""" +import os +from pathlib import Path +import shlex +import subprocess +import tempfile +import unittest + +from test_wan_dns import ROOT, SH, BUSYBOX + +# Stable legacy layout: keep testing an installation without wan_dns_metric +# after this fix becomes HEAD, and when tests run from a source archive. +LEGACY_DNS = '''wan_resolve_host() { + local host dns answer + host="$1"; dns="$(wan_dns_server)" || return 1 + answer="$(nslookup -timeout=3 -retry=1 "$host" "$dns" 2>/dev/null)" + printf '%s' "$answer" +} + +''' + + +@unittest.skipUnless(BUSYBOX or SH, "POSIX shell required") +class WanDnsDeploymentTests(unittest.TestCase): + def setUp(self): + self.temp = tempfile.TemporaryDirectory(prefix="wan-dns-deploy-") + self.addCleanup(self.temp.cleanup) + self.root = Path(self.temp.name) + self.target = self.root / "wan.sh" + self.backup = self.root / "backup" + self.current = (ROOT / "files/usr/lib/owrt-remote/wan.sh").read_text(encoding="utf-8") + self.published = (self.current.split("wan_dns_metric() {", 1)[0] + LEGACY_DNS + + "wan_endpoint_ip() {" + self.current.split("wan_endpoint_ip() {", 1)[1]) + self.target.write_text(self.published, encoding="utf-8", newline="\n") + source = (ROOT / "vps/deploy-wan-dns-fix.ps1").read_text(encoding="utf-8") + self.script = source.split("$RemoteScript = @'\n", 1)[1].split("\n'@", 1)[0] + self.script = self.script.replace("target=/usr/lib/owrt-remote/wan.sh", "target=" + shlex.quote(self.target.as_posix())) + self.script = self.script.replace("backup_dir=/root/owrt-remote-backup-before-wan-dns-v116", + "backup_dir=" + shlex.quote(self.backup.as_posix())) + + def deploy(self, action="Install", bad=False, fail_verify=False, fail_signal=False): + stage = self.root / "stage" + stage.mkdir() + block = "wan_dns_metric() {" + self.current.split("wan_dns_metric() {", 1)[1].split("wan_endpoint_ip() {", 1)[0] + if bad: + block = "if true; then\n" + stage.joinpath("dns.sh").write_text(block, encoding="utf-8", newline="\n") + script = self.script.replace("stage=/tmp/__UPLOAD_NAME__", "stage=" + shlex.quote(stage.as_posix())) + script = script.replace("__UPLOAD_NAME__", "sandbox").replace("__ACTION__", action) + if fail_verify: + script = script.replace('cmp "$source_file" "$target"', "false") + mocks = r''' +ubus() { + printf '%s\n' "$*" >>"$TEST_ROOT/ubus-calls" + if [ "$3" = signal ]; then + [ "${TEST_SIGNAL_FAIL:-0}" = 0 ] || return 1 + printf 202 >"$TEST_ROOT/pid" + fi + printf '{}' +} +jsonfilter() { cat >/dev/null; cat "$TEST_ROOT/pid"; } +sleep() { :; } +''' + self.root.joinpath("pid").write_text("101") + run = self.root / "run.sh" + run.write_text(mocks + script, encoding="utf-8", newline="\n") + args = [BUSYBOX, "ash"] if BUSYBOX else [SH] + env = dict(os.environ) + if not BUSYBOX and os.name == "nt": + env["PATH"] = str(Path(SH).parent) + os.pathsep + env["PATH"] + result = subprocess.run(args + [run.as_posix()], capture_output=True, encoding="utf-8", timeout=20, + env={**env, "TEST_ROOT": self.root.as_posix(), "TEST_SIGNAL_FAIL": "1" if fail_signal else "0"}) + self.assertFalse(stage.exists()) + self.assertFalse(list(self.root.glob("*.new-sandbox"))) + return result + + def test_published_and_local_transport_versions_keep_all_non_dns_code(self): + for before in (self.published, self.current): + with self.subTest(version="local" if before == self.current else "published"): + self.target.write_text(before, encoding="utf-8", newline="\n") + result = self.deploy() + self.assertEqual(result.returncode, 0, result.stderr) + after = self.target.read_text(encoding="utf-8") + prefix = before.split("wan_dns_metric() {" if "wan_dns_metric() {" in before else "wan_resolve_host() {", 1)[0] + suffix = "wan_endpoint_ip() {" + before.split("wan_endpoint_ip() {", 1)[1] + self.assertTrue(after.startswith(prefix)) + self.assertTrue(after.endswith(suffix)) + self.assertIn("nslookup -type=A -timeout=3 -retry=1", after) + self.assertIn("WAN_DNS_ROUTER_Install_OK", result.stdout) + self.assertNotIn('"instance":"xray"', self.root.joinpath("ubus-calls").read_text()) + + def test_repeated_install_then_rollback_preserves_first_backup(self): + previous = self.target.read_bytes() + for attempt in range(2): + result = self.deploy() + self.assertEqual(result.returncode, 0, result.stderr) + self.assertEqual(self.backup.joinpath("wan.sh").read_bytes(), previous) + result = self.deploy("Rollback") + self.assertEqual(result.returncode, 0, result.stderr) + self.assertEqual(self.target.read_bytes(), previous) + + def test_bad_candidate_and_missing_backup_leave_target_unchanged(self): + before = self.target.read_bytes() + for action, bad in (("Install", True), ("Rollback", False)): + result = self.deploy(action, bad) + self.assertNotEqual(result.returncode, 0) + self.assertEqual(self.target.read_bytes(), before) + self.assertFalse(self.backup.exists()) + + def test_unknown_target_structure_is_rejected_before_changes(self): + self.target.write_text("#!/bin/sh\necho unknown\n", encoding="utf-8", newline="\n") + before = self.target.read_bytes() + result = self.deploy() + self.assertNotEqual(result.returncode, 0) + self.assertEqual(self.target.read_bytes(), before) + self.assertFalse(self.backup.exists()) + + def test_verification_or_reload_failure_restores_previous_wan_helper(self): + before = self.target.read_bytes() + for kwargs in ({"fail_verify": True}, {"fail_signal": True}): + result = self.deploy(**kwargs) + self.assertNotEqual(result.returncode, 0) + self.assertIn("Restoring WAN helper", result.stderr) + self.assertEqual(self.target.read_bytes(), before) + self.assertNotIn("WAN_DNS_ROUTER_Install_OK", result.stdout) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_xray_apply.py b/tests/test_xray_apply.py index e1c4c3d..0d0e10e 100644 --- a/tests/test_xray_apply.py +++ b/tests/test_xray_apply.py @@ -84,7 +84,8 @@ render_page() { printf 'KIND=%s\nTITLE=%s\nBODY=%s\nDRAFT=%s\n' "$RESULT_KIND" " env={**self.env, "REQUEST_METHOD": "POST", "CONTENT_TYPE": "application/x-www-form-urlencoded", "CONTENT_LENGTH": str(len(body))}, timeout=20) self.assertEqual(result.returncode, 0, result.stderr.decode("utf-8", errors="replace")) - self.assertFalse(list(self.directory.glob("owrt-remote-*")), "CGI temporary files must be removed") + leftovers = [path for path in self.directory.glob("owrt-remote-*") if path.name != "owrt-remote-heartbeat-last"] + self.assertFalse(leftovers, "CGI temporary files must be removed") return result.stdout.decode("utf-8") def test_mobile_smart_quotes_reproduce_uci_255_and_are_repaired(self): @@ -219,7 +220,7 @@ logger() { :; } 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.assertIn("reason=http_client_context_failed", response) self.assertNotIn("каждая команда должна быть на отдельной строке", response) self.assertTrue(self.directory.joinpath("restarted").exists()) diff --git a/vps/deploy-heartbeat-transport-fix.ps1 b/vps/deploy-heartbeat-transport-fix.ps1 new file mode 100644 index 0000000..acba1ea --- /dev/null +++ b/vps/deploy-heartbeat-transport-fix.ps1 @@ -0,0 +1,152 @@ +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-heartbeat-transport-' + [guid]::NewGuid().ToString('N') +$StageRoot = Join-Path ([System.IO.Path]::GetTempPath()) $UploadName +$Utf8 = [System.Text.UTF8Encoding]::new($false) +$Payloads = @{ + 'wan.sh' = 'files\usr\lib\owrt-remote\wan.sh' + 'agent' = 'files\usr\sbin\owrt-remote' +} +$RemoteScript = @' +#!/bin/sh +set -eu +stage=/tmp/__UPLOAD_NAME__ +backup_dir=/root/owrt-remote-backup-before-heartbeat-transport-v116 +changed=0 +phase=preflight +item_path() { + case "$1" in + wan.sh) printf /usr/lib/owrt-remote/wan.sh ;; + agent) printf /usr/sbin/owrt-remote ;; + esac +} +complete_backup() { + [ -f "$1/complete" ] && [ -s "$1/wan.sh" ] && [ -s "$1/agent" ] +} +restore_files() { + local dir item path + dir=$1 + complete_backup "$dir" || return 1 + for item in agent wan.sh; 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 +} +heartbeat_pid() { + local state + state=$(ubus call service list '{"name":"owrt-remote"}') || return 1 + printf '%s' "$state" | jsonfilter -e '@["owrt-remote"].instances.heartbeat.pid' 2>/dev/null || true +} +refresh_heartbeat() { + local old_pid new_pid attempt + old_pid=$(heartbeat_pid) || return 1 + case "$old_pid" in ''|0) echo 'Heartbeat loop is stopped; files will be used at its next start.'; return 0 ;; *[!0-9]*) return 1 ;; esac + # Signal only the supervised heartbeat shell; procd respawns it from the + # new agent. The Xray instance and reverse tunnel stay running. + ubus call service signal '{"name":"owrt-remote","instance":"heartbeat","signal":9}' >/dev/null || return 1 + attempt=0 + while [ "$attempt" -lt 20 ]; do + sleep 1 + new_pid=$(heartbeat_pid) || return 1 + case "$new_pid" in ''|0|*[!0-9]*) ;; *) + [ "$new_pid" = "$old_pid" ] || { echo 'Heartbeat loop reloaded; Xray was not restarted.'; return 0; } ;; + esac + attempt=$((attempt+1)) + done + echo 'Heartbeat loop did not respawn. Code will be restored.' >&2 + return 1 +} +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 WAN helper from this attempt.' >&2 + restore_files "$stage/previous" && refresh_heartbeat || echo 'Restore failed; retained backup is available.' >&2 + fi + fi + for item in agent wan.sh; do path=$(item_path "$item"); rm -f "$path.new-__UPLOAD_NAME__"; done + rm -rf "$stage" + exit "$code" +} +trap cleanup EXIT +for item in agent wan.sh; do + path=$(item_path "$item") + test -s "$path" +done +heartbeat_pid >/dev/null +if [ '__ACTION__' = Install ]; then + for item in agent wan.sh; do test -s "$stage/$item"; sh -n "$stage/$item"; done + grep -F -q 'remote_curl_post()' "$stage/agent" + grep -F -q 'reason=https_required' "$stage/agent" + grep -F -q 'remote_curl_post' "$stage/wan.sh" + if [ ! -e "$backup_dir" ]; then + mkdir -p "$stage/retained-backup" + chmod 700 "$stage/retained-backup" + for item in agent wan.sh; 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 agent wan.sh; 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 agent wan.sh; do path=$(item_path "$item"); cp -p "$path" "$stage/previous/$item"; done +touch "$stage/previous/complete" +phase=install +changed=1 +for item in agent wan.sh; 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 agent wan.sh; do + path=$(item_path "$item") + sh -n "$path" + cmp "$source_dir/$item" "$path" +done +phase=heartbeat-reload +refresh_heartbeat +# Configuration, Xray and routing are not regenerated by this deployment. +printf '\nHEARTBEAT_TRANSPORT_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 "Heartbeat transport 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 } + } +} diff --git a/vps/deploy-wan-dns-fix.ps1 b/vps/deploy-wan-dns-fix.ps1 new file mode 100644 index 0000000..81efea7 --- /dev/null +++ b/vps/deploy-wan-dns-fix.ps1 @@ -0,0 +1,128 @@ +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-wan-dns-' + [guid]::NewGuid().ToString('N') +$StageRoot = Join-Path ([System.IO.Path]::GetTempPath()) $UploadName +$Utf8 = [System.Text.UTF8Encoding]::new($false) +$RemoteScript = @' +#!/bin/sh +set -eu +stage=/tmp/__UPLOAD_NAME__ +target=/usr/lib/owrt-remote/wan.sh +backup_dir=/root/owrt-remote-backup-before-wan-dns-v116 +changed=0 +phase=preflight +heartbeat_pid() { + local state + state=$(ubus call service list '{"name":"owrt-remote"}') || return 1 + printf '%s' "$state" | jsonfilter -e '@["owrt-remote"].instances.heartbeat.pid' 2>/dev/null || true +} +refresh_heartbeat() { + local old_pid new_pid attempt + old_pid=$(heartbeat_pid) || return 1 + case "$old_pid" in ''|0) echo 'Heartbeat is stopped; the fix will load at its next start.'; return 0 ;; *[!0-9]*) return 1 ;; esac + ubus call service signal '{"name":"owrt-remote","instance":"heartbeat","signal":9}' >/dev/null || return 1 + attempt=0 + while [ "$attempt" -lt 20 ]; do + sleep 1 + new_pid=$(heartbeat_pid) || return 1 + case "$new_pid" in ''|0|*[!0-9]*) ;; *) + [ "$new_pid" = "$old_pid" ] || { echo 'Heartbeat reloaded; Xray was not restarted.'; return 0; } ;; + esac + attempt=$((attempt+1)) + done + echo 'Heartbeat did not respawn.' >&2 + return 1 +} +restore_file() { + cp -p "$1" "$target.new-__UPLOAD_NAME__" && mv -f "$target.new-__UPLOAD_NAME__" "$target" +} +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 WAN helper from this attempt.' >&2 + restore_file "$stage/previous" && refresh_heartbeat || echo 'Restore failed; retained backup is available.' >&2 + fi + fi + rm -f "$target.new-__UPLOAD_NAME__" + rm -rf "$stage" + exit "$code" +} +trap cleanup EXIT +test -s "$target" +heartbeat_pid >/dev/null +if [ '__ACTION__' = Install ]; then + test -s "$stage/dns.sh" + sh -n "$stage/dns.sh" + grep -F -q 'nslookup -type=A -timeout=3 -retry=1' "$stage/dns.sh" + # Patch DNS functions only, preserving the router's other WAN code and + # compatibility with both the published and locally updated agent. + awk -v bundle="$stage/dns.sh" ' + /^(wan_dns_metric|wan_resolve_host)\(\) \{$/ && !seen { + while ((getline line < bundle)>0) print line + close(bundle); seen=1; skip=1 + } + /^wan_endpoint_ip\(\) \{$/ && skip { skip=0; finished=1 } + !skip { print } + END { if(!seen || !finished) exit 1 } + ' "$target" >"$stage/candidate" + sh -n "$stage/candidate" + if [ ! -e "$backup_dir" ]; then + mkdir "$stage/backup" + chmod 700 "$stage/backup" + cp -p "$target" "$stage/backup/wan.sh" + mv "$stage/backup" "$backup_dir" + fi + test -s "$backup_dir/wan.sh" + source_file="$stage/candidate" +else + [ -s "$backup_dir/wan.sh" ] || { echo "No backup: $backup_dir. Nothing changed." >&2; exit 1; } + sh -n "$backup_dir/wan.sh" + source_file="$backup_dir/wan.sh" +fi +printf 'Backup: %s/wan.sh\n' "$backup_dir" +cp -p "$target" "$stage/previous" +phase=install +changed=1 +cp -p "$target" "$target.new-__UPLOAD_NAME__" +cat "$source_file" >"$target.new-__UPLOAD_NAME__" +mv -f "$target.new-__UPLOAD_NAME__" "$target" +phase=verify +sh -n "$target" +cmp "$source_file" "$target" +phase=heartbeat-reload +refresh_heartbeat +printf '\nWAN_DNS_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') { + $Source = [System.IO.File]::ReadAllText((Join-Path $RepoRoot 'files\usr\lib\owrt-remote\wan.sh')).Replace("`r`n", "`n") + $Block = [regex]::Match($Source, '(?ms)^wan_dns_metric\(\) \{.*?(?=^wan_endpoint_ip\(\) \{)') + if (-not $Block.Success) { throw 'Local WAN DNS functions not found.' } + [System.IO.File]::WriteAllText((Join-Path $StageRoot 'dns.sh'), $Block.Value, $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 "WAN DNS 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 } + } +}