Fix HTTPS heartbeat retries and WAN IPv4 DNS fallback

This commit is contained in:
kzolotarev95 committed 2026-10-15 12:55:35 +04:00
1 parent 4a398c96b1
commit 5f65a3d811
13 files changed
+1547 -69

No files matched your search

+102 -25
View File
@@ -103,37 +103,114 @@ wan_dns_server() {
printf '%s' "$dns" 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() { 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" 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 case "$host" in ''|*[!a-zA-Z0-9_.-]*) return 1 ;; esac
dns="$(wan_dns_server)" || return 1 dns="$(wan_dns_server)" || return 1
cache="$WAN_STATE/resolve-$(safe_id "$host-$dns")" cache="$WAN_STATE/resolve-$(safe_id "$host-$dns")"
now="$(date +%s)" now="$(date +%s)"
saved_ts=0; saved_ip='' saved_ts=0; saved_ip=''
[ ! -r "$cache" ] || read -r saved_ts saved_ip <"$cache" if [ -r "$cache" ]; then
if [ -n "$saved_ip" ] && [ $((now - saved_ts)) -lt 300 ]; 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 printf '%s' "$saved_ip"; return
fi fi
# Query WAN's resolver explicitly, never the local dnsmasq/sing-box resolver. # Query WAN's resolver explicitly, never the local dnsmasq/sing-box resolver.
answer="$(nslookup -timeout=3 -retry=1 "$host" "$dns" 2>/dev/null | awk ' started=''
/^Name:/ { in_answer=1 } [ -z "${OWRT_REMOTE_DNS_METRICS:-}" ] || started="$(remote_clock_ms)"
in_answer && /^Address([[:space:]][0-9]+)?:/ { # Without -type=A BusyBox queries both A and AAAA, so an empty AAAA
for (i=2;i<=NF;i++) if ($i ~ /^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+$/) { print $i; exit } # answer can be confused with an IPv4 failure. Preserve nslookup status.
}')" rc=0
case "$answer" in 198.18.*|198.19.*) answer='' ;; esac reply="$(LC_ALL=C nslookup -type=A -timeout=3 -retry=1 "$host" "$dns" 2>&1)" || rc=$?
if wan_ip_literal "$answer"; then [ -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" mkdir -p "$WAN_STATE"
printf '%s %s\n' "$now" "$answer" >"$cache.tmp.$$" printf '%s %s\n' "$now" "$answer" >"$cache.tmp.$$"
mv "$cache.tmp.$$" "$cache" mv "$cache.tmp.$$" "$cache"
printf '%s' "$answer"; return printf '%s' "$answer"; return
fi fi
if [ -n "$saved_ip" ] && [ $((now - saved_ts)) -lt 3600 ]; then if [ -n "$saved_ip" ] && [ "$saved_age" -lt 3600 ]; then
log "WAN DNS unavailable for $host; using last successful WAN address $saved_ip" log "WAN DNS unavailable for $host; reason=$reason; resolver=$dns; rc=$rc; using last successful WAN address $saved_ip"
printf '%s' "$saved_ip"; return printf '%s' "$saved_ip"; return
fi 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 return 1
} }
@@ -143,6 +220,7 @@ wan_endpoint_ip() {
pinned="$(uci_get vps_host '')" pinned="$(uci_get vps_host '')"
# Preserve HTTP Host and TLS SNI while connecting to the manually pinned VPS. # 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 if ! wan_ip_literal "$host" && [ "$(vps_host_mode)" = manual ] && wan_ip_literal "$pinned"; then
wan_dns_metric 0 pinned
printf '%s' "$pinned" printf '%s' "$pinned"
else else
wan_resolve_host "$host" wan_resolve_host "$host"
@@ -388,9 +466,9 @@ wan_prepare() (
wan_prepare_locked wan_prepare_locked
) )
wan_post_json() { wan_http_target() {
local url token file host port ip device selected OWRT_REMOTE_ACTIVE_WAN_INTERFACE local url host port ip device selected OWRT_REMOTE_ACTIVE_WAN_INTERFACE
url="$1"; token="$2"; file="$3" url="$1"
selected="$(wan_select_interface)" || return 1 selected="$(wan_select_interface)" || return 1
if [ "$selected" != "$(cat "$WAN_STATE/active-interface" 2>/dev/null)" ]; then if [ "$selected" != "$(cat "$WAN_STATE/active-interface" 2>/dev/null)" ]; then
wan_prepare || return 1 wan_prepare || return 1
@@ -398,7 +476,7 @@ wan_post_json() {
OWRT_REMOTE_ACTIVE_WAN_INTERFACE="$(cat "$WAN_STATE/active-interface")" || return 1 OWRT_REMOTE_ACTIVE_WAN_INTERFACE="$(cat "$WAN_STATE/active-interface")" || return 1
host="$(wan_url_host "$url")" host="$(wan_url_host "$url")"
port="$(wan_url_port "$url")" || return 1 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 device="$(wan_device)" || return 1
# A resolver cache may expire between prepare and this request. Refresh # A resolver cache may expire between prepare and this request. Refresh
# direct routes before sending to a newly resolved IP. # 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 grep -Fqx "$ip $port" "$WAN_STATE/endpoints" || return 1
fi fi
case "$ip" in *:*) ip="[$ip]" ;; esac case "$ip" in *:*) ip="[$ip]" ;; esac
# Follow nginx HTTP-to-HTTPS redirects while preserving this JSON POST. printf '%s|%s:%s:%s' "$device" "$host" "$port" "$ip"
# 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 \ wan_post_json() {
--resolve "$host:$port:$ip" \ # Resolve and bind every approved redirect separately, including HTTPS.
-H "Authorization: Bearer $token" -H 'Content-Type: application/json' \ remote_curl_post "$1" "$2" "$3" wan
--data-binary "@$file" "$url"
} }
wan_cleanup() { wan_cleanup() {
+191 -27
View File
@@ -28,6 +28,7 @@ usage() {
owrt-remote run owrt-remote run
owrt-remote heartbeat owrt-remote heartbeat
owrt-remote heartbeat-loop owrt-remote heartbeat-loop
owrt-remote heartbeat-diagnostics
owrt-remote logs-sync owrt-remote logs-sync
owrt-remote network-diagnostics owrt-remote network-diagnostics
@@ -813,6 +814,108 @@ heartbeat_json() {
EOF 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() ( post_json() (
local url token file local url token file
url="$1" url="$1"
@@ -827,13 +930,10 @@ post_json() (
fi fi
if command -v curl >/dev/null 2>&1; then if command -v curl >/dev/null 2>&1; then
curl -fsSL --location --max-redirs 3 --post301 --post302 --post303 \ remote_curl_post "$url" "$token" "$file"
--connect-timeout 4 --max-time 10 --noproxy '*' \
-H "Authorization: Bearer $token" \
-H "Content-Type: application/json" \
--data-binary "@$file" "$url"
return return
fi 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 if command -v wget >/dev/null 2>&1; then
wget -q -T 10 -O - \ wget -q -T 10 -O - \
--header="Authorization: Bearer $token" \ --header="Authorization: Bearer $token" \
@@ -918,6 +1018,7 @@ heartbeat_emit_endpoint() {
local base marker local base marker
base="$(normalize_url_base "$1")" base="$(normalize_url_base "$1")"
[ -n "$base" ] || return 0 [ -n "$base" ] || return 0
case "${HEARTBEAT_REQUIRE_HTTPS:-0}|$base" in 1'|'http://*) return 0 ;; esac
marker="|$base|" marker="|$base|"
case "${HEARTBEAT_ENDPOINT_SEEN:-}" in case "${HEARTBEAT_ENDPOINT_SEEN:-}" in
*"$marker"*) return 0 ;; *"$marker"*) return 0 ;;
@@ -927,11 +1028,13 @@ heartbeat_emit_endpoint() {
} }
heartbeat_candidate_endpoints() { heartbeat_candidate_endpoints() {
local hub_url public_url vps_host local hub_url public_url vps_host HEARTBEAT_REQUIRE_HTTPS
HEARTBEAT_ENDPOINT_SEEN='|' HEARTBEAT_ENDPOINT_SEEN='|'
hub_url="$(uci_get hub_url '')" hub_url="$(uci_get hub_url '')"
public_url="$(uci_get public_url '')" public_url="$(uci_get public_url '')"
vps_host="$(uci_get vps_host '')" 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 "$hub_url"
heartbeat_emit_endpoint "$public_url" heartbeat_emit_endpoint "$public_url"
case "$vps_host" in case "$vps_host" in
@@ -1010,8 +1113,31 @@ heartbeat_apply_hub_update() {
fi fi
} }
send_heartbeat() { heartbeat_failure_reason() {
local hub_url token endpoint tmp response event used fallback_base errors rc 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:-}" event="${1:-}"
hub_url="$(uci_get hub_url '')" hub_url="$(uci_get hub_url '')"
token="$(uci_get hub_token '')" token="$(uci_get hub_token '')"
@@ -1023,34 +1149,68 @@ send_heartbeat() {
wan_reconcile_xray wan_reconcile_xray
fi fi
endpoint="${hub_url%/}/api/heartbeat" dir="$(mktemp -d "${TMPDIR:-/tmp}/owrt-remote-heartbeat.XXXXXX")" || return 1
tmp="${TMPDIR:-/tmp}/owrt-remote-heartbeat.$$" chmod 700 "$dir"
response="${TMPDIR:-/tmp}/owrt-remote-heartbeat.response.$$" 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" errors="$response.error"
metrics="$dir/metrics"
export OWRT_REMOTE_HTTP_METRICS="$metrics"
heartbeat_json "$event" >"$tmp" heartbeat_json "$event" >"$tmp"
used=0 used=0
previous=''; previous_reason=''
for endpoint in $(heartbeat_candidate_endpoints); do for endpoint in $(heartbeat_candidate_endpoints); do
used=1 used=1
rc=0 safe_endpoint="$(remote_url_origin "$endpoint")" || { log 'Heartbeat: ошибка; reason=invalid_endpoint'; continue; }
post_json "$endpoint" "$token" "$tmp" >"$response" 2>"$errors" || rc=$? if [ -n "$previous" ]; then
if [ "$rc" = 0 ] && grep -Eq '"ok"[[:space:]]*:[[:space:]]*true' "$response"; then log "Heartbeat: fallback; from=$previous; to=$safe_endpoint; reason=$previous_reason; предыдущие попытки исчерпаны"
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
fi 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 done
rm -f "$tmp" "$response" "$errors"
[ "$used" = "1" ] || die "hub_url/public_url/vps_host пустые" [ "$used" = "1" ] || die "hub_url/public_url/vps_host пустые"
case "$hub_url" in https://*) log 'Heartbeat: fallback остановлен; reason=https_required; автоматический переход на HTTP отключён' ;; esac
return 1 return 1
} )
wan_reconcile_xray() { wan_reconcile_xray() {
local config bound device local config bound device
@@ -1417,6 +1577,7 @@ case "$cmd" in
;; ;;
network-diagnostics) network-diagnostics)
wan_diagnostics wan_diagnostics
heartbeat_diagnostics
;; ;;
install-xray-tmp) install-xray-tmp)
install_xray_tmp install_xray_tmp
@@ -1440,6 +1601,9 @@ case "$cmd" in
heartbeat-loop) heartbeat-loop)
heartbeat_loop heartbeat_loop
;; ;;
heartbeat-diagnostics)
heartbeat_diagnostics
;;
logs-sync) logs-sync)
sync_global_logs sync_global_logs
;; ;;
+120
View File
@@ -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. На реальный
роутер этот локальный фикс автоматически не устанавливался.
+73
View File
@@ -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.
+288
View File
@@ -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()
+122
View File
@@ -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()
+11 -10
View File
@@ -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") 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): 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(''' result = self.run_shell('''
heartbeat_json() { printf '{"id":"test-router"}'; } heartbeat_json() { printf '{"id":"test-router"}'; }
post_json() { post_json() {
case "$1" in case "$1" in
http://193.233.82.38:8088/api/heartbeat) printf '{"ok":true}' ;; https://backup.example/api/heartbeat) printf '{"ok":true}' ;;
*) return 1 ;; *) return 1 ;;
esac esac
} }
@@ -428,11 +428,11 @@ printf '%s' "$(uci_get hub_url '')"
self.assertIn("<pppoe-wan>", args) self.assertIn("<pppoe-wan>", args)
self.assertIn("<https://hub.example/api/heartbeat>", args) self.assertIn("<https://hub.example/api/heartbeat>", args)
self.assertNotIn("<-k>", args) self.assertNotIn("<-k>", args)
self.assertIn("<--max-time>\n<10>", args) self.assertIn("<--max-time>", args)
self.assertIn("<--location>", args) self.assertIn("<--resolve>", args)
self.assertIn("<--post301>", args) self.assertIn("<--data-binary>", args)
self.assertIn("<--post302>", args) self.assertNotIn("<--location-trusted>", args)
self.assertIn("<--post303>", args) self.assertNotIn("<--location>", args)
def test_busybox_empty_table_is_confirmed_before_wan_start(self): 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") 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(result.returncode, 0, result.stderr)
self.assertEqual(self.directory.joinpath("xray-called").read_text().strip(), 'run -config ' + config.as_posix()) 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") self.config(vps_host="193.233.82.38", vps_host_mode="manual")
result = self.run_shell(''' result = self.run_shell('''
curl() { curl() {
@@ -498,8 +498,9 @@ post_json http://hub.example/api/heartbeat test-token "$TEST_ROOT/payload"
''') ''')
self.assertEqual(result.returncode, 0, result.stderr) self.assertEqual(result.returncode, 0, result.stderr)
args = (self.directory / "curl").read_text() args = (self.directory / "curl").read_text()
self.assertIn("<--location>", args) self.assertIn("<Authorization: Bearer test-token>", args)
self.assertIn("<--post301>", args) self.assertIn("<--data-binary>", args)
self.assertNotIn("<--location>", args)
def test_literal_ip_fallback_is_not_rewritten_to_a_different_pin(self): 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") self.config(vps_host="193.233.82.38", vps_host_mode="manual")
+9 -5
View File
@@ -34,14 +34,18 @@ wan_prepare() { echo prepare >>"$TEST_ROOT/requests"; [ "${TEST_WAN_FAIL:-0}" !=
xray_running() { [ "${TEST_XRAY_RUNNING:-0}" = 1 ]; } xray_running() { [ "${TEST_XRAY_RUNNING:-0}" = 1 ]; }
wan_post_json() { echo direct >>"$TEST_ROOT/requests"; fake_post "$1" "$3"; } wan_post_json() { echo direct >>"$TEST_ROOT/requests"; fake_post "$1" "$3"; }
curl() { curl() {
local file arg next url local file arg next url output
next=0; file='' next=''; file=''; output=''
for arg in "$@"; do for arg in "$@"; do
[ "$next" != 1 ] || { file="${arg#@}"; next=0; } case "$next" in
[ "$arg" != --data-binary ] || next=1 data) file="${arg#@}"; next=''; continue ;;
output) output="$arg"; next=''; continue ;;
esac
case "$arg" in --data-binary) next=data ;; -o) next=output ;; esac
url="$arg" url="$arg"
done 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() { fake_post() {
echo "$1" >>"$TEST_ROOT/requests" echo "$1" >>"$TEST_ROOT/requests"
+219
View File
@@ -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()
+129
View File
@@ -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()
+3 -2
View File
@@ -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", env={**self.env, "REQUEST_METHOD": "POST", "CONTENT_TYPE": "application/x-www-form-urlencoded",
"CONTENT_LENGTH": str(len(body))}, timeout=20) "CONTENT_LENGTH": str(len(body))}, timeout=20)
self.assertEqual(result.returncode, 0, result.stderr.decode("utf-8", errors="replace")) 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") return result.stdout.decode("utf-8")
def test_mobile_smart_quotes_reproduce_uci_255_and_are_repaired(self): 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")) response = self.post(script.replace("\n", "\r\n"))
self.assertIn("KIND=bad", response) self.assertIn("KIND=bad", response)
self.assertIn("Ошибка отправки Heartbeat после применения настроек", 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.assertNotIn("каждая команда должна быть на отдельной строке", response)
self.assertTrue(self.directory.joinpath("restarted").exists()) self.assertTrue(self.directory.joinpath("restarted").exists())
+152
View File
@@ -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 }
}
}
+128
View File
@@ -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 }
}
}