Merge origin/main into the 0.5.0 redesign

Brings in 0.4.8: connection log, uninstall and update from the awg-ctrl menu,
secret panel path, stealth hub and sen:// port, random I1/MTU on install.
install.sh keeps the new output (spinner, cards, outdated-install wipe) on top
of the reorganised installer; an outdated install can be reinstalled with a
wipe or removed. The connection log tab uses the MD3 segmented button; its
metrics-token scrape snippet moved to Settings.

internal/ctrl/awg.go

@@ -345,8 +345,10 @@ func (s *Server) syncPeers() error {
 func (s *Server) reloadAwgParams() string {
 	p := ReadParams(s.confPath(), func(m string) { s.log.Warn(m) })
 	p.I1 = s.getCfg(cfgI1, p.I1)
+	mtu := ReadMTU(s.confPath())
 	s.cfgMu.Lock()
 	s.c.Params = p
+	s.c.MTU = mtu
 	s.c.Gen = p.Gen()
 	s.c.Keepalive = keepaliveByGen[s.c.Gen]
 	g := s.c.Gen

internal/ctrl/connlog.go

@@ -0,0 +1,287 @@
+package ctrl
+
+// Журнал VPN-подключений: кто, когда подключился и отключился, сколько длилась сессия и сколько
+// прошло трафика, и когда каждый пир был на связи последний раз (для «кто давно не подключался»).
+//
+// У WireGuard нет событий подключения — только время последнего handshake и счётчики байт в
+// `awg show dump`. Раз в 30 с сверяем их с открытыми сессиями:
+//   - пир стал онлайн (handshake моложе 3 мин) — «подключился» со временем этого handshake;
+//   - пир ушёл из онлайна или с интерфейса — «отключился» со временем последней активности
+//     (последнего тика, когда менялись счётчики): handshake идёт раз в 2 мин, активность точнее.
+// Открытые сессии восстанавливаются из базы, поэтому перезапуск awg-ctrl не плодит дублей.
+// Внешний IP клиента не пишем: это уже слежка, а не журнал.
+
+import (
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+)
+
+const (
+	connlogEvery = 30 * time.Second
+	connlogKeepS = 90 * 24 * 3600 // столько дней храним события
+	seenEveryS   = 60             // last_seen пишем не чаще раза в минуту на пира
+	connlogLimit = 500
+)
+
+type connSession struct {
+	since          int64
+	rx0, tx0       float64 // счётчики на начало сессии
+	lastRx, lastTx float64
+	active         int64 // последний тик, когда менялись счётчики
+	seenSaved      int64
+}
+
+type peerIdent struct{ name, owner, ip string }
+
+type ConnLog struct {
+	s       *Server
+	mu      sync.Mutex
+	open    map[string]*connSession
+	loaded  bool
+	pruned  int64
+	peersFn func() (map[string]peerStat, bool) // подменяется в тестах
+}
+
+func newConnLog(s *Server) *ConnLog {
+	l := &ConnLog{s: s, open: map[string]*connSession{}}
+	l.peersFn = func() (map[string]peerStat, bool) {
+		if !s.interfaceStatus().Up {
+			return nil, false // интерфейс лежит — это не «все отключились», а пауза
+		}
+		return s.getPeersData(), true
+	}
+	return l
+}
+
+func (l *ConnLog) Start() {
+	go func() {
+		for {
+			l.tick(time.Now().Unix())
+			time.Sleep(connlogEvery)
+		}
+	}()
+}
+
+// idents — имя пользователя или владелец пира sen:// и внутренний IP по публичному ключу. Строки
+// читаем до конца до любых других запросов: соединение с SQLite одно (см. metrics_test.go).
+func (l *ConnLog) idents() map[string]peerIdent {
+	out := map[string]peerIdent{}
+	if rows, err := l.s.db.Query("SELECT pub_key, name, ip FROM users"); err == nil {
+		for rows.Next() {
+			var pub, name, ip string
+			if rows.Scan(&pub, &name, &ip) == nil {
+				out[pub] = peerIdent{name: name, ip: ip}
+			}
+		}
+		rows.Close()
+	}
+	if rows, err := l.s.db.Query("SELECT pub_key, owner, ip FROM peers"); err == nil {
+		for rows.Next() {
+			var pub, owner, ip string
+			if rows.Scan(&pub, &owner, &ip) == nil {
+				out[pub] = peerIdent{owner: owner, ip: ip}
+			}
+		}
+		rows.Close()
+	}
+	return out
+}
+
+// load — открытые сессии (последнее событие пира — «подключился») после перезапуска.
+func (l *ConnLog) load(now int64) {
+	type row struct {
+		pub        string
+		at, rx, tx int64
+		seen       int64
+	}
+	var open []row
+	rows, err := l.s.db.Query(`SELECT c.pub_key, c.at, COALESCE(c.rx, 0), COALESCE(c.tx, 0), COALESCE(s.at, c.at)
+		FROM conn_log c
+		JOIN (SELECT pub_key, MAX(id) AS id FROM conn_log GROUP BY pub_key) last ON last.id = c.id
+		LEFT JOIN peer_seen s ON s.pub_key = c.pub_key
+		WHERE c.event = 'connect'`)
+	if err != nil {
+		return
+	}
+	for rows.Next() {
+		var r row
+		if rows.Scan(&r.pub, &r.at, &r.rx, &r.tx, &r.seen) == nil {
+			open = append(open, r)
+		}
+	}
+	rows.Close()
+	for _, r := range open {
+		l.open[r.pub] = &connSession{since: r.at, rx0: float64(r.rx), tx0: float64(r.tx),
+			lastRx: float64(r.rx), lastTx: float64(r.tx), active: r.seen, seenSaved: r.seen}
+	}
+	l.loaded = true
+}
+
+func (l *ConnLog) tick(now int64) {
+	stats, ok := l.peersFn()
+	if !ok {
+		return
+	}
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	if !l.loaded {
+		l.load(now)
+	}
+	who := l.idents()
+	write := func(event, pub string, at int64, dur *int64, rx, tx float64) {
+		id := who[pub]
+		var d any
+		if dur != nil {
+			d = *dur
+		}
+		l.s.db.Exec("INSERT INTO conn_log (at, event, pub_key, name, owner, ip, duration, rx, tx) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
+			at, event, pub, id.name, id.owner, id.ip, d, int64(rx), int64(tx))
+	}
+	seen := func(pub string, at int64) {
+		l.s.db.Exec("INSERT INTO peer_seen (pub_key, at) VALUES (?, ?) ON CONFLICT(pub_key) DO UPDATE SET at = excluded.at", pub, at)
+	}
+	closeSession := func(pub string, sess *connSession) {
+		at := max(sess.active, sess.since)
+		dur := at - sess.since
+		// Счётчики сбрасываются при перезапуске интерфейса: тогда считаем от нуля.
+		rx, tx := sess.lastRx-sess.rx0, sess.lastTx-sess.tx0
+		if rx < 0 {
+			rx = sess.lastRx
+		}
+		if tx < 0 {
+			tx = sess.lastTx
+		}
+		write("disconnect", pub, at, &dur, rx, tx)
+		seen(pub, at)
+		delete(l.open, pub)
+	}
+
+	for pub, st := range stats {
+		sess := l.open[pub]
+		switch {
+		case st.Online && sess == nil:
+			at := int64(st.LastHandshake)
+			if at <= 0 || at > now {
+				at = now
+			}
+			write("connect", pub, at, nil, st.Rx, st.Tx)
+			l.open[pub] = &connSession{since: at, rx0: st.Rx, tx0: st.Tx, lastRx: st.Rx, lastTx: st.Tx, active: now, seenSaved: now}
+			seen(pub, now)
+		case st.Online:
+			if st.Rx != sess.lastRx || st.Tx != sess.lastTx {
+				sess.lastRx, sess.lastTx, sess.active = st.Rx, st.Tx, now
+			}
+			if now-sess.seenSaved >= seenEveryS {
+				seen(pub, sess.active)
+				sess.seenSaved = now
+			}
+		case sess != nil:
+			if hs := int64(st.LastHandshake); hs > sess.active && hs <= now {
+				sess.active = hs
+			}
+			if st.Rx > sess.lastRx || st.Tx > sess.lastTx {
+				sess.lastRx, sess.lastTx = st.Rx, st.Tx
+			}
+			closeSession(pub, sess)
+		}
+	}
+	// Пира сняли с интерфейса (удалили пользователя, перевыпустили ключ) посреди сессии.
+	for pub, sess := range l.open {
+		if _, ok := stats[pub]; !ok {
+			closeSession(pub, sess)
+		}
+	}
+	if now-l.pruned >= 3600 {
+		l.s.db.Exec("DELETE FROM conn_log WHERE at < ?", now-connlogKeepS)
+		l.pruned = now
+	}
+}
+
+// list — GET /api/connlog: события (новые сверху) и «когда был на связи» по каждому пиру.
+//
+//	?limit=N (до 500), ?before=<id> — следующая страница, ?q=<строка> — по имени, владельцу, IP.
+func (l *ConnLog) list(limit, before int64, q string) (ob, error) {
+	if limit <= 0 || limit > connlogLimit {
+		limit = connlogLimit
+	}
+	where, args := []string{"1 = 1"}, []any{}
+	if before > 0 {
+		where, args = append(where, "id < ?"), append(args, before)
+	}
+	if q = strings.TrimSpace(q); q != "" {
+		like := "%" + strings.NewReplacer(`\`, `\\`, "%", `\%`, "_", `\_`).Replace(q) + "%"
+		where = append(where, `(name LIKE ? ESCAPE '\' OR owner LIKE ? ESCAPE '\' OR ip LIKE ? ESCAPE '\')`)
+		args = append(args, like, like, like)
+	}
+	args = append(args, limit)
+	rows, err := l.s.db.Query("SELECT id, at, event, pub_key, name, owner, ip, duration, rx, tx FROM conn_log WHERE "+
+		strings.Join(where, " AND ")+" ORDER BY id DESC LIMIT ?", args...)
+	if err != nil {
+		return nil, err
+	}
+	events := []any{}
+	for rows.Next() {
+		var id, at int64
+		var event, pub, name, owner, ip string
+		var dur, rx, tx *int64
+		if err := rows.Scan(&id, &at, &event, &pub, &name, &owner, &ip, &dur, &rx, &tx); err != nil {
+			rows.Close()
+			return nil, err
+		}
+		e := ob{{"id", id}, {"at", at}, {"event", event}, {"pub_key", pub}, {"name", name}, {"owner", owner}, {"ip", ip}}
+		if event == "disconnect" {
+			e = append(e, kv{"duration", deref(dur)}, kv{"rx", deref(rx)}, kv{"tx", deref(tx)})
+		}
+		events = append(events, e)
+	}
+	rows.Close()
+
+	// Все пиры сервера с последним временем на связи (null — с тех пор, как ведётся журнал, не было).
+	stats := map[string]peerStat{}
+	if st, ok := l.peersFn(); ok {
+		stats = st
+	}
+	peers := []any{}
+	rows, err = l.s.db.Query(`SELECT u.pub_key, u.name, '' AS owner, u.ip, s.at FROM users u LEFT JOIN peer_seen s ON s.pub_key = u.pub_key
+		UNION ALL
+		SELECT p.pub_key, '', p.owner, p.ip, s.at FROM peers p LEFT JOIN peer_seen s ON s.pub_key = p.pub_key`)
+	if err != nil {
+		return nil, err
+	}
+	for rows.Next() {
+		var pub, name, owner, ip string
+		var at *int64
+		if err := rows.Scan(&pub, &name, &owner, &ip, &at); err != nil {
+			rows.Close()
+			return nil, err
+		}
+		var last any
+		if at != nil {
+			last = *at
+		}
+		peers = append(peers, ob{{"pub_key", pub}, {"name", name}, {"owner", owner}, {"ip", ip},
+			{"online", stats[pub].Online}, {"last_seen", last}})
+	}
+	rows.Close()
+
+	var since any
+	var first int64
+	if l.s.db.QueryRow("SELECT MIN(at) FROM conn_log").Scan(&first) == nil && first > 0 {
+		since = first
+	}
+	return ob{{"events", events}, {"peers", peers}, {"since", since}, {"keep_days", connlogKeepS / 86400}}, nil
+}
+
+func deref(p *int64) any {
+	if p == nil {
+		return nil
+	}
+	return *p
+}
+
+func queryInt(c *rctx, k string) int64 {
+	n, _ := strconv.ParseInt(c.r.URL.Query().Get(k), 10, 64)
+	return n
+}

internal/ctrl/connlog_test.go

@@ -0,0 +1,116 @@
+package ctrl
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/maeneko/forgetting/internal/jsjson"
+	"github.com/maeneko/forgetting/internal/logx"
+)
+
+func TestConnLog(t *testing.T) {
+	db, err := openDB(filepath.Join(t.TempDir(), "users.db"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+	db.Exec("INSERT INTO users (name, ip, pub_key, vpn_key) VALUES ('ivan', '10.9.0.2', 'PK_IVAN', 'vpn://x')")
+	db.Exec("INSERT INTO peers (pub_key, ip, psk_key, owner, created_at) VALUES ('PK_PHONE', '10.9.0.3', 'psk', 'p1/m1/d2', 1)")
+	s := &Server{db: db, iface: "awg1", log: logx.New(os.Stderr, t.TempDir())}
+
+	stats := map[string]peerStat{}
+	up := true
+	newLog := func() *ConnLog {
+		l := newConnLog(s)
+		l.peersFn = func() (map[string]peerStat, bool) {
+			cp := map[string]peerStat{}
+			for k, v := range stats {
+				cp[k] = v
+			}
+			return cp, up
+		}
+		return l
+	}
+	l := newLog()
+	peer := func(pub string, online bool, hs, rx, tx float64) {
+		stats[pub] = peerStat{Online: online, LastHandshake: hs, Rx: rx, Tx: tx}
+	}
+	events := func() string {
+		v, err := l.list(0, 0, "")
+		if err != nil {
+			t.Fatal(err)
+		}
+		var b []string
+		for _, e := range v.Get2("events").([]any) {
+			o := e.(jsjson.Object)
+			s := o.Get2("event").(string) + " " + o.Get2("name").(string) + o.Get2("owner").(string) + " @" + string(jsjson.MustMarshal(o.Get2("at")))
+			if o.Get2("event") == "disconnect" {
+				s += " dur=" + string(jsjson.MustMarshal(o.Get2("duration"))) + " rx=" + string(jsjson.MustMarshal(o.Get2("rx")))
+			}
+			b = append([]string{s}, b...) // старые сверху — читать проще
+		}
+		return strings.Join(b, "; ")
+	}
+
+	peer("PK_IVAN", false, 0, 0, 0)
+	peer("PK_PHONE", false, 0, 0, 0)
+	l.tick(1000)
+	if got := events(); got != "" {
+		t.Fatalf("без онлайна событий быть не должно: %s", got)
+	}
+
+	peer("PK_IVAN", true, 1010, 100, 50) // подключился, handshake в 1010
+	l.tick(1030)
+	peer("PK_IVAN", true, 1010, 900, 300) // качает
+	l.tick(1060)
+	peer("PK_IVAN", true, 1130, 900, 300) // keepalive-handshake без трафика
+	l.tick(1150)
+	up = false // интерфейс лёг — это не отключение
+	l.tick(1180)
+	up = true
+	peer("PK_IVAN", false, 1130, 900, 300)
+	l.tick(1330)
+	if got, want := events(), "connect ivan @1010; disconnect ivan @1130 dur=120 rx=800"; got != want {
+		t.Fatalf("сессия:\n got %s\nwant %s", got, want)
+	}
+
+	// Перезапуск awg-ctrl посреди сессии: новый ConnLog поднимает открытую сессию из базы.
+	peer("PK_PHONE", true, 2000, 10, 10)
+	l.tick(2010)
+	l = newLog()
+	peer("PK_PHONE", true, 2100, 70, 10)
+	l.tick(2110)
+	// Пира сняли с интерфейса (удалили устройство) — сессия закрывается.
+	delete(stats, "PK_PHONE")
+	l.tick(2140)
+	want := "connect ivan @1010; disconnect ivan @1130 dur=120 rx=800; connect p1/m1/d2 @2000; disconnect p1/m1/d2 @2110 dur=110 rx=60"
+	if got := events(); got != want {
+		t.Fatalf("после перезапуска:\n got %s\nwant %s", got, want)
+	}
+
+	// Счётчики сбросились (перезапуск интерфейса) — трафик сессии считается с нуля, не уходит в минус.
+	peer("PK_IVAN", true, 3000, 5000, 5000)
+	l.tick(3010)
+	peer("PK_IVAN", true, 3100, 40, 40)
+	l.tick(3110)
+	peer("PK_IVAN", false, 3100, 40, 40)
+	l.tick(3400)
+	if got := events(); !strings.HasSuffix(got, "connect ivan @3000; disconnect ivan @3110 dur=110 rx=40") {
+		t.Fatalf("сброс счётчиков: %s", got)
+	}
+
+	v, _ := l.list(0, 0, "")
+	seen := map[string]any{}
+	for _, p := range v.Get2("peers").([]any) {
+		o := p.(jsjson.Object)
+		seen[o.Get2("pub_key").(string)] = o.Get2("last_seen")
+	}
+	if seen["PK_IVAN"] != float64(3110) && seen["PK_IVAN"] != int64(3110) {
+		t.Errorf("last_seen ivan: %v", seen["PK_IVAN"])
+	}
+	if f, _ := l.list(0, 0, "ivan"); len(f.Get2("events").([]any)) != 4 {
+		t.Errorf("поиск по имени: %d событий", len(f.Get2("events").([]any)))
+	}
+}

internal/ctrl/db.go

@@ -100,6 +100,26 @@ func initSchema(db *sql.DB) error {
             psk_key    TEXT NOT NULL,
             owner      TEXT NOT NULL DEFAULT '',
             created_at INTEGER NOT NULL
+        )`,
+		// Журнал VPN-подключений (connlog.go). name/owner/ip — на момент события: пользователя
+		// могут удалить, а запись о нём остаётся.
+		`CREATE TABLE IF NOT EXISTS conn_log (
+            id       INTEGER PRIMARY KEY AUTOINCREMENT,
+            at       INTEGER NOT NULL,
+            event    TEXT    NOT NULL,
+            pub_key  TEXT    NOT NULL,
+            name     TEXT    NOT NULL DEFAULT '',
+            owner    TEXT    NOT NULL DEFAULT '',
+            ip       TEXT    NOT NULL DEFAULT '',
+            duration INTEGER,
+            rx       INTEGER,
+            tx       INTEGER
+        )`,
+		"CREATE INDEX IF NOT EXISTS idx_conn_log_at ON conn_log (at)",
+		"CREATE INDEX IF NOT EXISTS idx_conn_log_pub ON conn_log (pub_key, id)",
+		`CREATE TABLE IF NOT EXISTS peer_seen (
+            pub_key TEXT PRIMARY KEY,
+            at      INTEGER NOT NULL
         )`,
 	} {
 		if _, err := db.Exec(q); err != nil {

internal/ctrl/params.go

@@ -70,6 +70,28 @@ var AWG31Defaults = [][2]string{
 	{"MaxHandshakeAttempts", "15-20"},
 }
 
+// DefaultMTU — MTU установок до рандомизации; запасное, если в awg1.conf его нет или оно странное.
+const DefaultMTU = 1376
+
+// ReadMTU читает MTU из [Interface] awg1.conf: install.sh выбирает его случайно, у каждого
+// сервера своё, и клиенты получают его в vpn:// ключе.
+func ReadMTU(confFile string) int {
+	raw, err := os.ReadFile(confFile)
+	if err != nil {
+		return DefaultMTU
+	}
+	iface := pPeerSplit.Split(string(raw), 2)[0]
+	m := regexp.MustCompile(`(?m)^\s*MTU\s*=\s*(\d+)`).FindStringSubmatch(iface)
+	if m == nil {
+		return DefaultMTU
+	}
+	n, _ := strconv.Atoi(m[1])
+	if n < 1280 || n > 1500 {
+		return DefaultMTU
+	}
+	return n
+}
+
 // При заданном HeaderProtectionKey ни один из S1–S4 не может быть меньше 12.
 const minSForHeaderProtection = 12
 

internal/ctrl/routes.go

@@ -37,6 +37,14 @@ func (s *Server) routes() []route {
 				{"awg", ob{{"status", awgSt}, {"peers", st.Peers}, {"module", cfg.AwgModule}, {"tools", cfg.AwgTools}}}}}, nil
 		}),
 
+		R("GET", "/api/connlog", false, a, func(c *rctx) (result, error) {
+			v, err := s.connlog.list(queryInt(c, "limit"), queryInt(c, "before"), c.r.URL.Query().Get("q"))
+			if err != nil {
+				return result{}, err
+			}
+			return ok(v)
+		}),
+
 		R("POST", "/api/users", true, an, func(c *rctx) (result, error) {
 			name, _ := c.obj().Get2("name").(string)
 			if u, err := s.userGet(name); err != nil {

internal/ctrl/server.go

@@ -56,6 +56,7 @@ type Server struct {
 
 	shaping *Shaping
 	torrent *Torrent
+	connlog *ConnLog
 	metrics metricsCache
 	monitor monitorJob
 	cliPath string
@@ -151,13 +152,14 @@ func New() (*Server, error) {
 	module, tools := readVersions()
 	s.c = Config{
 		ServerIP: ip, ServerPort: sp, ServerName: name,
-		DNS1: "1.1.1.1", DNS2: "1.0.0.1", MTU: 1376, Subnet: "10.9",
+		DNS1: "1.1.1.1", DNS2: "1.0.0.1", MTU: ReadMTU(s.confPath()), Subnet: "10.9",
 		Keepalive: keepaliveByGen[gen], Params: params, Gen: gen,
 		AwgModule: module, AwgTools: tools,
 	}
 	s.log.Info("awg params loaded from conf", "Jc", params.Jc, "H1", params.H1, "gen", gen)
 	s.shaping = newShaping(s)
 	s.torrent = newTorrent(s)
+	s.connlog = newConnLog(s)
 	return s, nil
 }
 
@@ -186,5 +188,6 @@ func (s *Server) Run() error {
 	go s.shaping.Apply()
 	s.shaping.Start()
 	go s.torrent.Apply() // nft-таблицы после перезагрузки нет — ставим заново
+	s.connlog.Start()
 	return <-errc
 }