initial commit: wirecon WireGuard stack

Rootless-Docker server (wireguard-go + Caddy sharing netns) and
unprivileged-LXC client (kernel WG + systemd watchdog/monitor/MTU-probe)
with curl-pipeable bootstrap. Tuned for Telekom DSL/LTE Hybrid uplinks.
This commit is contained in:
d4nn13 committed 2026-04-19 18:20:21 +02:00
commit 49b01dfcd3
19 files changed
+770

No files matched your search

+92
View File
@@ -0,0 +1,92 @@
#!/bin/bash
# wirecon-monitor.sh — long-running observer. Emits one structured log line
# every MONITOR_INTERVAL seconds with handshake age, throughput deltas,
# endpoint, and in-tunnel RTT. Designed to make silent-death diagnosable
# after the fact via journalctl.
set -uo pipefail
CONF="${WIRECON_CONF:-/etc/wirecon/wirecon.conf}"
# shellcheck source=/dev/null
[[ -r "$CONF" ]] && source "$CONF"
: "${WG_INTERFACE:=wg0}"
: "${PEER_IP:=10.42.0.1}"
: "${MONITOR_INTERVAL:=10}"
prev_rx=""
prev_tx=""
prev_hs=""
prev_ep=""
prev_mtu=""
log() {
local level="$1"; shift
printf 'level=%s ts=%s %s\n' "$level" "$(date -u +%FT%TZ)" "$*"
}
rtt_probe() {
# single ping, short timeout, returns ms or "-"
local out rtt
out=$(ping -I "$WG_INTERFACE" -c 1 -W 2 -n "$PEER_IP" 2>/dev/null) || { echo "-"; return; }
rtt=$(echo "$out" | awk -F'=' '/time=/{split($NF,a," "); print a[1]; exit}')
[[ -z "$rtt" ]] && rtt="-"
echo "$rtt"
}
log info "event=monitor_start iface=$WG_INTERFACE peer_ip=$PEER_IP interval=${MONITOR_INTERVAL}s"
while :; do
if ! ip link show "$WG_INTERFACE" >/dev/null 2>&1; then
log warn "event=iface_missing iface=$WG_INTERFACE"
sleep "$MONITOR_INTERVAL"
continue
fi
# wg show <iface> dump has one header line then one per peer:
# iface: private pub listen_port fwmark
# peer: pub psk endpoint allowed_ips last_handshake rx_bytes tx_bytes keepalive
dump=$(wg show "$WG_INTERFACE" dump 2>/dev/null | awk 'NR==2')
if [[ -z "$dump" ]]; then
log warn "event=no_peer_dump iface=$WG_INTERFACE"
sleep "$MONITOR_INTERVAL"
continue
fi
endpoint=$(awk '{print $3}' <<<"$dump")
hs_ts=$(awk '{print $5}' <<<"$dump")
rx=$(awk '{print $6}' <<<"$dump")
tx=$(awk '{print $7}' <<<"$dump")
mtu=$(ip -o link show "$WG_INTERFACE" | awk '{for(i=1;i<=NF;i++) if($i=="mtu"){print $(i+1); exit}}')
now=$(date +%s)
hs_age=-1
[[ "$hs_ts" != "0" && -n "$hs_ts" ]] && hs_age=$((now - hs_ts))
# byte deltas (bps averaged over interval)
rx_bps="-"; tx_bps="-"
if [[ -n "$prev_rx" && -n "$prev_tx" ]]; then
rx_bps=$(( (rx - prev_rx) * 8 / MONITOR_INTERVAL ))
tx_bps=$(( (tx - prev_tx) * 8 / MONITOR_INTERVAL ))
fi
rtt=$(rtt_probe)
# Highlight state changes at warn level so they're easy to grep.
level=info
notes=""
if [[ -n "$prev_ep" && "$prev_ep" != "$endpoint" ]]; then
level=warn; notes+=" endpoint_changed_from=$prev_ep"
fi
if [[ -n "$prev_mtu" && "$prev_mtu" != "$mtu" ]]; then
level=warn; notes+=" mtu_changed_from=$prev_mtu"
fi
if [[ -n "$prev_hs" && "$prev_hs" != "0" && "$hs_ts" == "$prev_hs" && "$hs_age" -gt 180 ]]; then
level=warn; notes+=" handshake_stuck"
fi
log "$level" "event=tick iface=$WG_INTERFACE endpoint=$endpoint handshake_age=${hs_age}s mtu=$mtu rtt_ms=$rtt rx_bps=$rx_bps tx_bps=$tx_bps rx_total=$rx tx_total=$tx${notes}"
prev_rx="$rx"; prev_tx="$tx"; prev_hs="$hs_ts"; prev_ep="$endpoint"; prev_mtu="$mtu"
sleep "$MONITOR_INTERVAL"
done
+65
View File
@@ -0,0 +1,65 @@
#!/bin/bash
# wirecon-mtu-probe.sh — find the largest payload that survives PMTUD toward
# the WG peer's public endpoint, then print the recommended WG MTU
# (payload - 80 bytes of WG/UDP/IPv4 overhead).
#
# Usage: wirecon-mtu-probe.sh [<target_host>]
# If <target_host> is omitted, reads the Endpoint from /etc/wireguard/wg0.conf.
set -euo pipefail
CONF="${WIRECON_CONF:-/etc/wirecon/wirecon.conf}"
# shellcheck source=/dev/null
[[ -r "$CONF" ]] && source "$CONF"
: "${MTU_MIN:=1200}"
: "${MTU_MAX:=1420}"
target="${1:-}"
if [[ -z "$target" ]]; then
# extract Endpoint host from wg0.conf
target=$(awk -F'= *' '/^Endpoint/ {gsub(/:[0-9]+$/,"",$2); print $2; exit}' /etc/wireguard/wg0.conf 2>/dev/null || true)
fi
if [[ -z "$target" ]]; then
echo "usage: $0 <target_host>" >&2
exit 2
fi
echo "probing PMTU toward $target (range $MTU_MIN..$MTU_MAX)" >&2
# ICMP payload = mtu - 28 (IP+ICMP headers)
probe_ok() {
local mtu=$1 payload=$((mtu - 28))
ping -M do -s "$payload" -c 1 -W 2 -n "$target" >/dev/null 2>&1
}
lo=$MTU_MIN
hi=$MTU_MAX
best=0
if ! probe_ok "$lo"; then
echo "FAIL: even $lo does not pass DF — path is broken or host unreachable" >&2
exit 1
fi
best=$lo
while [[ $lo -le $hi ]]; do
mid=$(( (lo + hi) / 2 ))
if probe_ok "$mid"; then
best=$mid
lo=$(( mid + 1 ))
else
hi=$(( mid - 1 ))
fi
done
# WireGuard-over-IPv4-over-UDP overhead: 20 (IPv4) + 8 (UDP) + 32 (WG) = 60.
# Round down to 80 for safety margin (covers IPv6, extra hops).
wg_mtu=$(( best - 80 ))
echo "path MTU: $best"
echo "recommended WG MTU: $wg_mtu"
echo
echo "apply on both peers:"
echo " sudo sed -i 's/^MTU = .*/MTU = ${wg_mtu}/' /etc/wireguard/wg0.conf"
echo " sudo systemctl restart wg-quick@wg0"
+108
View File
@@ -0,0 +1,108 @@
#!/bin/bash
# wirecon-watchdog.sh — invoked periodically by wirecon-watchdog.timer.
#
# Checks handshake age and in-tunnel reachability. If either fails for
# FAIL_STREAK_THRESHOLD consecutive ticks, bounces the WG interface and
# logs the reason.
#
# All output goes to stdout/stderr; systemd routes it to journald under
# SYSLOG_IDENTIFIER=wirecon-watchdog.
set -uo pipefail
CONF="${WIRECON_CONF:-/etc/wirecon/wirecon.conf}"
# shellcheck source=/dev/null
[[ -r "$CONF" ]] && source "$CONF"
: "${WG_INTERFACE:=wg0}"
: "${PEER_IP:=10.42.0.1}"
: "${HANDSHAKE_MAX_AGE:=180}"
: "${PING_COUNT:=3}"
: "${PING_TIMEOUT:=2}"
: "${PING_LOSS_THRESHOLD:=3}"
: "${FAIL_STREAK_THRESHOLD:=2}"
: "${STATE_DIR:=/run/wirecon}"
mkdir -p "$STATE_DIR"
STREAK_FILE="$STATE_DIR/fail_streak"
LAST_RECONNECT_FILE="$STATE_DIR/last_reconnect"
# Structured single-line log. kv pairs => easy to grep / jq via journalctl.
log() {
local level="$1"; shift
printf 'level=%s ts=%s %s\n' "$level" "$(date -u +%FT%TZ)" "$*"
}
read_streak() {
[[ -r "$STREAK_FILE" ]] && cat "$STREAK_FILE" || echo 0
}
write_streak() { echo "$1" > "$STREAK_FILE"; }
handshake_age() {
# `wg show <iface> latest-handshakes` → "<peer_pubkey>\t<unix_ts>"
local ts now
ts=$(wg show "$WG_INTERFACE" latest-handshakes 2>/dev/null | awk 'NR==1{print $2}')
[[ -z "$ts" || "$ts" == "0" ]] && { echo -1; return; }
now=$(date +%s)
echo $((now - ts))
}
in_tunnel_ping() {
# returns number of lost pings (0..PING_COUNT)
local out loss
out=$(ping -I "$WG_INTERFACE" -c "$PING_COUNT" -W "$PING_TIMEOUT" -n "$PEER_IP" 2>&1) || true
loss=$(echo "$out" | awk -F',' '/packet loss/ {gsub(/[^0-9]/,"",$3); print $3}')
# loss is percent; convert to absolute count
[[ -z "$loss" ]] && { echo "$PING_COUNT"; return; }
echo $(( PING_COUNT * loss / 100 ))
}
reconnect() {
local reason="$1"
log warn "event=reconnect reason=\"$reason\" iface=$WG_INTERFACE"
date -u +%FT%TZ > "$LAST_RECONNECT_FILE"
# `wg-quick down` can fail if the iface is already gone — that's fine.
wg-quick down "$WG_INTERFACE" 2>&1 | sed 's/^/ down: /' || true
sleep 1
if wg-quick up "$WG_INTERFACE" 2>&1 | sed 's/^/ up: /'; then
log info "event=reconnect_ok iface=$WG_INTERFACE"
write_streak 0
else
log error "event=reconnect_failed iface=$WG_INTERFACE"
fi
}
# --- main check --------------------------------------------------------------
# 1. Is the interface even there?
if ! ip link show "$WG_INTERFACE" >/dev/null 2>&1; then
log error "event=iface_missing iface=$WG_INTERFACE"
reconnect "interface missing"
exit 0
fi
age=$(handshake_age)
lost=$(in_tunnel_ping)
streak=$(read_streak)
reason=""
if [[ "$age" -lt 0 ]]; then
reason="no handshake ever"
elif [[ "$age" -gt "$HANDSHAKE_MAX_AGE" ]]; then
reason="handshake stale age=${age}s max=${HANDSHAKE_MAX_AGE}s"
elif [[ "$lost" -ge "$PING_LOSS_THRESHOLD" ]]; then
reason="ping loss=${lost}/${PING_COUNT}"
fi
if [[ -n "$reason" ]]; then
streak=$((streak + 1))
write_streak "$streak"
log warn "event=check_fail streak=$streak/$FAIL_STREAK_THRESHOLD handshake_age=${age}s ping_lost=${lost}/${PING_COUNT} reason=\"$reason\""
if [[ "$streak" -ge "$FAIL_STREAK_THRESHOLD" ]]; then
reconnect "$reason (streak=$streak)"
fi
else
[[ "$streak" -ne 0 ]] && log info "event=recovered streak_was=$streak handshake_age=${age}s"
write_streak 0
log info "event=ok handshake_age=${age}s ping_lost=${lost}/${PING_COUNT}"
fi