maeneko
3511b8c6c3
masterDevices skips a server that did not answer and reports it as unreachable; peers are fetched once per server per pass. The tab loads each key on its own, counts devices from the key when the list is missing (and still asks before unbinding), drops stale responses, labels an IP from another server and blocks a double create. masterFor answers 403 instead of 404 for a key that exists but is outside the API key's servers, so a client does not mistake it for a deleted one. updateMaster checks every statement in its transaction.
866 lines
28 KiB
Go
866 lines
28 KiB
Go
package ui
|
||
|
||
// Мастер-ключи: общая логика панели и внешнего API (порт части awg-ui/sub.ts). Панель
|
||
// (/ui/masterkeys, /ui/devices, за JWT) видит всё. Внешний API (/api/v1/masterkeys, ключ
|
||
// awgk_) — только ключи, чьи серверы целиком входят в набор серверов API-ключа: иначе он мог бы
|
||
// удалить или перенастроить раздачу на сервере, которого не видит. scope: nil — панель.
|
||
|
||
import (
|
||
"crypto/rand"
|
||
"database/sql"
|
||
"errors"
|
||
"fmt"
|
||
"regexp"
|
||
"sort"
|
||
"strings"
|
||
"sync"
|
||
"time"
|
||
|
||
"github.com/google/uuid"
|
||
|
||
"github.com/maeneko/forgetting/internal/jsjson"
|
||
)
|
||
|
||
type apiError struct {
|
||
status int
|
||
msg string
|
||
}
|
||
|
||
func (e *apiError) Error() string { return e.msg }
|
||
|
||
func fail(status int, msg string) error { return &apiError{status, msg} }
|
||
|
||
// aw — apiError даёт свой статус; остальное (awg-ctrl не ответил посреди действия) — 502.
|
||
func aw(fn func(c *Ctx) (int, any, error)) handler {
|
||
return func(c *Ctx) bool {
|
||
var (
|
||
st int
|
||
v any
|
||
err error
|
||
)
|
||
func() {
|
||
defer func() {
|
||
if p := recover(); p != nil {
|
||
err = fmt.Errorf("%v", p)
|
||
}
|
||
}()
|
||
st, v, err = fn(c)
|
||
}()
|
||
var ae *apiError
|
||
if errors.As(err, &ae) {
|
||
return c.Error(ae.status, ae.msg)
|
||
}
|
||
if err != nil {
|
||
return c.Error(502, "awg-ctrl недоступен")
|
||
}
|
||
return c.JSON(st, v)
|
||
}
|
||
}
|
||
|
||
var (
|
||
reUUID = regexp.MustCompile(`(?i)^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$`)
|
||
reLabel = regexp.MustCompile(`^[^\r\n<>]+$`) // длина — lenOK(1, 40): в JS {1,40} считает UTF-16
|
||
)
|
||
|
||
func labelOK(v any) (string, bool) {
|
||
s, ok := v.(string)
|
||
return s, ok && reLabel.MatchString(s) && lenOK(s, 1, 40)
|
||
}
|
||
|
||
// idOf — Number(v), если это безопасное целое, иначе -1 (не найдётся).
|
||
func idOf(v string) int64 {
|
||
f := jsToNumber(v)
|
||
if !isSafeInt(f) {
|
||
return -1
|
||
}
|
||
return int64(f)
|
||
}
|
||
|
||
// masterIdOf — мастер-ключ в пути: числовой id или uuid.
|
||
func (s *Sub) masterIDOf(v string) int64 {
|
||
if reUUID.MatchString(v) {
|
||
var id int64
|
||
if s.a.db.QueryRow("SELECT id FROM master_keys WHERE uuid = ?", strings.ToLower(v)).Scan(&id) != nil {
|
||
return -1
|
||
}
|
||
return id
|
||
}
|
||
return idOf(v)
|
||
}
|
||
|
||
func limitOK(v any) (int64, bool) {
|
||
f, ok := v.(float64)
|
||
return int64(f), ok && f == float64(int64(f)) && f >= 1 && f <= 100
|
||
}
|
||
|
||
func (s *Sub) visible(masterID int64, scope []int) bool {
|
||
if scope == nil {
|
||
return true
|
||
}
|
||
for _, id := range s.serverIDsOf(s.a.db, masterID) {
|
||
if !containsInt(scope, id) {
|
||
return false
|
||
}
|
||
}
|
||
return true
|
||
}
|
||
|
||
// masterFor — живой (не удаляемый) ключ в пределах области. Ключ, которого нет или который
|
||
// удалён, — 404; ключ, у которого есть сервер вне области API-ключа, — 403: клиент не должен
|
||
// принимать его за удалённый и выдавать вместо него второй (так у пользователя появлялся дубль).
|
||
func (s *Sub) masterFor(id int64, scope []int) (*masterRow, error) {
|
||
m := s.masterByID(s.a.db, id)
|
||
if m == nil {
|
||
return nil, fail(404, "Не найден")
|
||
}
|
||
if !s.visible(m.ID, scope) {
|
||
return nil, fail(403, "Ключ вне области API-ключа")
|
||
}
|
||
return m, nil
|
||
}
|
||
|
||
// deviceFor — устройство; у внешнего API — только вместе со своим мастер-ключом.
|
||
func (s *Sub) deviceFor(id int64, master *masterRow) (*deviceRow, error) {
|
||
d := s.deviceByID(s.a.db, id)
|
||
if d == nil || master != nil && d.MasterID != master.ID {
|
||
return nil, fail(404, "Не найдено")
|
||
}
|
||
return d, nil
|
||
}
|
||
|
||
// parseServers — набор серверов из тела: непустой, без повторов, только существующие и — для
|
||
// внешнего API — только из области его ключа.
|
||
func (s *Sub) parseServers(v any, scope []int) ([]int, error) {
|
||
list, ok := v.([]any)
|
||
if !ok || len(list) == 0 {
|
||
return nil, fail(400, "Нужен хотя бы один сервер")
|
||
}
|
||
if len(list) > maxServers {
|
||
return nil, fail(400, fmt.Sprintf("Не больше %d серверов", maxServers))
|
||
}
|
||
ids, ok := s.a.serverList(v, s.a.nodes.Exists)
|
||
if !ok {
|
||
return nil, fail(400, "Такого сервера нет")
|
||
}
|
||
if scope != nil {
|
||
for _, id := range ids {
|
||
if !containsInt(scope, id) {
|
||
return nil, fail(403, "Сервер вне области API-ключа")
|
||
}
|
||
}
|
||
}
|
||
return ids, nil
|
||
}
|
||
|
||
// masterOut — deleting: ключ удалён, но эти серверы ещё не подтвердили, что сняли его пиров.
|
||
func (s *Sub) masterOut(m *masterRow) jsjson.Object {
|
||
srv := intsJSON(s.serverIDsOf(s.a.db, m.ID))
|
||
o := jsjson.Object{{Key: "id", Val: m.ID}, {Key: "uuid", Val: m.UUID}, {Key: "label", Val: m.Label}, {Key: "device_limit", Val: m.DeviceLimit},
|
||
{Key: "devices", Val: m.Devices}, {Key: "servers", Val: srv}, {Key: "created_at", Val: m.CreatedAt}}
|
||
if m.RevokedAt.Valid {
|
||
o = append(o, jsjson.KV{Key: "deleting", Val: srv})
|
||
}
|
||
return o
|
||
}
|
||
|
||
func (s *Sub) masterOutByID(id int64) jsjson.Object { return s.masterOut(s.masterRowByID(s.a.db, id)) }
|
||
|
||
func (s *Sub) listMasters(scope []int) []any {
|
||
rows, err := s.a.db.Query("SELECT " + masterCols + ", (SELECT COUNT(*) FROM devices d WHERE d.master_id = m.id) AS devices FROM master_keys m ORDER BY id")
|
||
if err != nil {
|
||
return []any{}
|
||
}
|
||
var ms []*masterRow
|
||
for rows.Next() {
|
||
if m := scanMaster(rows, true); m != nil {
|
||
ms = append(ms, m)
|
||
}
|
||
}
|
||
rows.Close()
|
||
out := []any{}
|
||
for _, m := range ms {
|
||
if s.visible(m.ID, scope) {
|
||
out = append(out, s.masterOut(m))
|
||
}
|
||
}
|
||
return out
|
||
}
|
||
|
||
// createMaster — серверы по умолчанию: у панели — сервер по умолчанию, у API-ключа — вся его область.
|
||
func (s *Sub) createMaster(body any, scope []int) (jsjson.Object, error) {
|
||
b, _ := body.(jsjson.Object)
|
||
label, ok := labelOK(b.Get2("label"))
|
||
if !ok {
|
||
return nil, fail(400, "Метка: до 40 символов, без переводов строк и <>")
|
||
}
|
||
limitV, hasLimit := b.Get("device_limit")
|
||
limit := int64(defaultLimit)
|
||
if hasLimit {
|
||
var ok bool
|
||
if limit, ok = limitOK(limitV); !ok {
|
||
return nil, fail(400, "Лимит устройств: от 1 до 100")
|
||
}
|
||
}
|
||
wanted, hasWanted := b.Get("servers")
|
||
src := wanted
|
||
if src == nil {
|
||
if scope != nil {
|
||
list := []any{} // как пришло бы из JSON: числа — float64
|
||
for _, id := range scope {
|
||
list = append(list, float64(id))
|
||
}
|
||
src = list
|
||
} else {
|
||
src = []any{float64(s.a.nodes.DefaultID())}
|
||
}
|
||
}
|
||
ids, err := s.parseServers(src, scope)
|
||
if err != nil {
|
||
if !hasWanted && scope == nil {
|
||
return nil, fail(400, "Сначала добавьте сервер")
|
||
}
|
||
return nil, err
|
||
}
|
||
secret := make([]byte, 16)
|
||
rand.Read(secret)
|
||
var id int64
|
||
err = s.a.tx(func(tx *sql.Tx) error {
|
||
r, err := tx.Exec("INSERT INTO master_keys (uuid, label, secret, device_limit, server_id, created_at) VALUES (?, ?, ?, ?, ?, ?)",
|
||
uuid.NewString(), label, secret, limit, ids[0], now())
|
||
if err != nil {
|
||
return err
|
||
}
|
||
id, _ = r.LastInsertId()
|
||
for _, sid := range ids {
|
||
if _, err := tx.Exec("INSERT OR IGNORE INTO master_servers (master_id, server_id) VALUES (?, ?)", id, sid); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
return nil
|
||
})
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return s.masterOutByID(id), nil
|
||
}
|
||
|
||
func (s *Sub) updateMaster(m *masterRow, body any, scope []int) (jsjson.Object, error) {
|
||
b, _ := body.(jsjson.Object)
|
||
nlV := b.Get2("label")
|
||
if nlV == nil {
|
||
nlV = m.Label
|
||
}
|
||
ndV := b.Get2("device_limit")
|
||
if ndV == nil {
|
||
ndV = float64(m.DeviceLimit)
|
||
}
|
||
nl, ok := labelOK(nlV)
|
||
if !ok {
|
||
return nil, fail(400, "Неверная метка")
|
||
}
|
||
nd, ok := limitOK(ndV)
|
||
if !ok {
|
||
return nil, fail(400, "Лимит устройств: от 1 до 100")
|
||
}
|
||
|
||
ids := s.serverIDsOf(s.a.db, m.ID)
|
||
var affected []int
|
||
if wanted, has := b.Get("servers"); has {
|
||
next, err := s.parseServers(wanted, scope)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
var added, removed []int
|
||
for _, x := range next {
|
||
if !containsInt(ids, x) {
|
||
added = append(added, x)
|
||
}
|
||
}
|
||
for _, x := range ids {
|
||
if !containsInt(next, x) {
|
||
removed = append(removed, x)
|
||
}
|
||
}
|
||
devices := s.devicesOf(s.a.db, m.ID)
|
||
if err := s.a.tx(func(tx *sql.Tx) error {
|
||
for _, sid := range removed {
|
||
if _, err := tx.Exec("DELETE FROM master_servers WHERE master_id = ? AND server_id = ?", m.ID, sid); err != nil {
|
||
return err
|
||
}
|
||
for _, d := range devices {
|
||
for _, l := range s.linksOf(tx, d.ID) {
|
||
if l.ServerID == sid && l.PeerPub.Valid {
|
||
if _, err := tx.Exec("INSERT OR IGNORE INTO peer_tombstones (server_id, pub_key) VALUES (?, ?)", sid, l.PeerPub.String); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
}
|
||
if _, err := tx.Exec("DELETE FROM device_peers WHERE device_id = ? AND server_id = ?", d.ID, sid); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
}
|
||
for _, sid := range added {
|
||
if _, err := tx.Exec("INSERT OR IGNORE INTO master_servers (master_id, server_id) VALUES (?, ?)", m.ID, sid); err != nil {
|
||
return err
|
||
}
|
||
for _, d := range devices {
|
||
if _, err := tx.Exec("INSERT OR IGNORE INTO device_peers (device_id, server_id) VALUES (?, ?)", d.ID, sid); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
}
|
||
return nil
|
||
}); err != nil {
|
||
return nil, err
|
||
}
|
||
affected = append(append(affected, added...), removed...)
|
||
ids = next
|
||
}
|
||
s.a.db.Exec("UPDATE master_keys SET label = ?, device_limit = ? WHERE id = ?", nl, nd, m.ID)
|
||
// Лимит стал меньше, чем устройств: лишние отвязываются, начиная с подключившихся последними.
|
||
unbound := []any{}
|
||
devices := s.devicesOf(s.a.db, m.ID)
|
||
if int64(len(devices)) > nd {
|
||
newest := append([]*deviceRow{}, devices...)
|
||
sort.SliceStable(newest, func(i, j int) bool {
|
||
if newest[i].CreatedAt != newest[j].CreatedAt {
|
||
return newest[i].CreatedAt > newest[j].CreatedAt
|
||
}
|
||
return newest[i].ID > newest[j].ID
|
||
})
|
||
for _, d := range newest[:int64(len(devices))-nd] {
|
||
affected = append(affected, s.forgetDeviceTx(d)...)
|
||
unbound = append(unbound, d.ID)
|
||
}
|
||
}
|
||
s.reconcileAll(affected)
|
||
return jsjson.Object{{Key: "id", Val: m.ID}, {Key: "label", Val: nl}, {Key: "device_limit", Val: nd},
|
||
{Key: "servers", Val: intsJSON(ids)}, {Key: "unbound", Val: unbound}}, nil
|
||
}
|
||
|
||
// rotateMaster — новая ссылка; устройства продолжают работать: у них auth_pub, а не secret.
|
||
func (s *Sub) rotateMaster(m *masterRow) {
|
||
secret := make([]byte, 16)
|
||
rand.Read(secret)
|
||
s.a.db.Exec("UPDATE master_keys SET secret = ? WHERE id = ?", secret, m.ID)
|
||
}
|
||
|
||
func (s *Sub) rekeyMaster(m *masterRow) {
|
||
s.a.db.Exec("UPDATE devices SET rekey_requested = 1 WHERE id = ? OR master_id = ?", -1, m.ID)
|
||
}
|
||
|
||
// deleteMaster — ключ сразу перестаёт работать, но строка остаётся отозванной, пока каждый его
|
||
// сервер не подтвердит, что снял пиров.
|
||
func (s *Sub) deleteMaster(m *masterRow) jsjson.Object {
|
||
affected := s.serverIDsOf(s.a.db, m.ID)
|
||
s.a.tx(func(tx *sql.Tx) error {
|
||
for _, d := range s.devicesOf(tx, m.ID) {
|
||
affected = append(affected, s.forgetDevice(tx, d)...)
|
||
}
|
||
_, err := tx.Exec("UPDATE master_keys SET revoked_at = ? WHERE id = ?", now(), m.ID)
|
||
return err
|
||
})
|
||
s.reconcileAll(affected)
|
||
return jsjson.Object{{Key: "success", Val: true}, {Key: "id", Val: m.ID}, {Key: "pending", Val: intsJSON(s.serverIDsOf(s.a.db, m.ID))}}
|
||
}
|
||
|
||
// linkProblem — выдать ссылку можно, только если подписка настроена и известен адрес панели.
|
||
func (s *Sub) linkProblem(c *Ctx) string {
|
||
if s.key() == nil || s.signPub == nil || s.port == 0 {
|
||
return "Подписка не настроена на сервере"
|
||
}
|
||
if s.subHost(c) == "" {
|
||
return "Не удалось определить адрес панели — задайте SUB_HOST"
|
||
}
|
||
return ""
|
||
}
|
||
|
||
func (s *Sub) linkOf(m *masterRow, c *Ctx) (jsjson.Object, error) {
|
||
if p := s.linkProblem(c); p != "" {
|
||
return nil, fail(503, p)
|
||
}
|
||
link, err := EncodeSenLink(SenLink{TLS: s.tlsPin != nil, Addrs: []SenAddr{{s.subHost(c), s.port}},
|
||
Secret: m.Secret, SignPub: s.signPub, TLSPin: s.tlsPin, Name: m.Label})
|
||
if err != nil {
|
||
return nil, err // как в Node: не ApiError — 502
|
||
}
|
||
return jsjson.Object{{Key: "link", Val: link}, {Key: "tls", Val: s.tlsPin != nil}}, nil
|
||
}
|
||
|
||
type devStat struct {
|
||
online bool
|
||
lastHS float64
|
||
rx, tx float64
|
||
background bool
|
||
torrent bool
|
||
}
|
||
|
||
// peersTTL — сколько держится ответ GET /api/peers сервера. Вкладка за один проход просит
|
||
// устройства каждого ключа, и без этого каждый запрос заново тянул бы пиров со всех серверов.
|
||
const peersTTL = 3 * time.Second
|
||
|
||
type peersCall struct {
|
||
done chan struct{} // закрывается, когда ответ получен
|
||
at time.Time // нулевое — ответ не годится для повторного использования (ошибка)
|
||
peers []any
|
||
err error
|
||
}
|
||
|
||
// peersOf — пиры сервера с их статистикой. Параллельные запросы к одному серверу делят один
|
||
// вызов; свежий ответ переиспользуется peersTTL, ошибка — нет.
|
||
func (s *Sub) peersOf(id int) ([]any, error) {
|
||
s.peersMu.Lock()
|
||
if c := s.peerCalls[id]; c != nil {
|
||
select {
|
||
case <-c.done:
|
||
if !c.at.IsZero() && time.Since(c.at) < peersTTL {
|
||
s.peersMu.Unlock()
|
||
return c.peers, c.err
|
||
}
|
||
default: // уже идёт — дождаться его же
|
||
s.peersMu.Unlock()
|
||
<-c.done
|
||
return c.peers, c.err
|
||
}
|
||
}
|
||
c := &peersCall{done: make(chan struct{})}
|
||
s.peerCalls[id] = c
|
||
s.peersMu.Unlock()
|
||
|
||
r, err := s.a.nodes.CtrlFor(id)("GET", "/api/peers", nil)
|
||
switch {
|
||
case err != nil:
|
||
c.err = err
|
||
case !ok2xx(r.Status):
|
||
c.err = fmt.Errorf("awg-ctrl ответил %d", r.Status)
|
||
default:
|
||
c.peers = arr(field(r.Data, "peers"))
|
||
c.at = time.Now()
|
||
}
|
||
close(c.done)
|
||
return c.peers, c.err
|
||
}
|
||
|
||
// masterDevices — статистика устройства по всем серверам ключа: онлайн, если есть свежий
|
||
// handshake хоть на одном; трафик суммируется. servers_ok — где уже стоит его текущий ключ.
|
||
// Сервер, который не ответил, не рушит список: его статистики просто нет, а id возвращается
|
||
// вторым значением — панель покажет, что данные неполные.
|
||
func (s *Sub) masterDevices(m *masterRow) ([]any, []int) {
|
||
stats := map[string]*devStat{}
|
||
var mu sync.Mutex
|
||
var wg sync.WaitGroup
|
||
unreachable := []int{}
|
||
for _, id := range s.serverIDsOf(s.a.db, m.ID) {
|
||
if !s.a.nodes.IsOnline(id) {
|
||
continue
|
||
}
|
||
wg.Add(1)
|
||
go func() {
|
||
defer wg.Done()
|
||
peers, err := s.peersOf(id)
|
||
mu.Lock()
|
||
defer mu.Unlock()
|
||
if err != nil {
|
||
unreachable = append(unreachable, id)
|
||
return
|
||
}
|
||
for _, p := range peers {
|
||
pub, _ := field(p, "pub_key").(string)
|
||
st := stats[pub]
|
||
if st == nil {
|
||
st = &devStat{}
|
||
stats[pub] = st
|
||
}
|
||
st.online = st.online || truthy(field(p, "online"))
|
||
if h := numOr(field(p, "lastHandshake"), 0); h > st.lastHS {
|
||
st.lastHS = h
|
||
}
|
||
st.rx += numOr(field(p, "rx"), 0)
|
||
st.tx += numOr(field(p, "tx"), 0)
|
||
// Устройство стоит на каждом сервере со своим IP; фоновым его делает любой из них.
|
||
st.background = st.background || field(p, "priority") == "background"
|
||
st.torrent = st.torrent || truthy(field(p, "torrent"))
|
||
}
|
||
}()
|
||
}
|
||
wg.Wait()
|
||
sort.Ints(unreachable)
|
||
out := []any{}
|
||
for _, d := range s.devicesOf(s.a.db, m.ID) {
|
||
links := s.linksOf(s.a.db, d.ID)
|
||
st := stats[d.PubKey]
|
||
if st == nil {
|
||
st = &devStat{}
|
||
}
|
||
okN := 0
|
||
ips := []any{} // IP устройства на каждом сервере ключа, где он уже выдан
|
||
for _, l := range links {
|
||
if l.PeerPub.Valid && l.PeerPub.String == d.PubKey && l.IP.Valid && l.IP.String != "" {
|
||
okN++
|
||
}
|
||
if l.IP.Valid && l.IP.String != "" {
|
||
ips = append(ips, jsjson.Object{{Key: "server_id", Val: l.ServerID}, {Key: "ip", Val: l.IP.String}})
|
||
}
|
||
}
|
||
prio := "normal"
|
||
if st.background {
|
||
prio = "background"
|
||
}
|
||
out = append(out, jsjson.Object{
|
||
{Key: "id", Val: d.ID}, {Key: "device_id", Val: d.DeviceID}, {Key: "device_name", Val: d.DeviceName}, {Key: "platform", Val: d.Platform},
|
||
{Key: "version", Val: d.Version}, {Key: "created_at", Val: d.CreatedAt}, {Key: "last_seen", Val: nullInt(d.LastSeen)},
|
||
{Key: "rekey_requested", Val: d.RekeyRequested == 1}, {Key: "online", Val: st.online}, {Key: "lastHandshake", Val: st.lastHS},
|
||
{Key: "rx", Val: st.rx}, {Key: "tx", Val: st.tx}, {Key: "priority", Val: prio},
|
||
{Key: "torrent", Val: st.torrent},
|
||
{Key: "servers_total", Val: len(links)}, {Key: "servers_ok", Val: okN}, {Key: "ips", Val: ips},
|
||
})
|
||
}
|
||
return out, unreachable
|
||
}
|
||
|
||
func (s *Sub) deleteDevice(d *deviceRow) jsjson.Object {
|
||
s.reconcileAll(s.forgetDeviceTx(d))
|
||
return jsjson.Object{{Key: "success", Val: true}, {Key: "id", Val: d.ID}}
|
||
}
|
||
|
||
func (s *Sub) rekeyDevice(d *deviceRow) {
|
||
s.a.db.Exec("UPDATE devices SET rekey_requested = 1 WHERE id = ? OR master_id = ?", d.ID, -1)
|
||
}
|
||
|
||
// rotatePsk — новый PSK на каждом сервере; недоступные получат его, когда появятся.
|
||
func (s *Sub) rotatePsk(d *deviceRow) jsjson.Object {
|
||
s.a.db.Exec("UPDATE device_peers SET psk_pending = 1 WHERE device_id = ? AND peer_pub IS NOT NULL", d.ID)
|
||
var ids []int
|
||
for _, l := range s.linksOf(s.a.db, d.ID) {
|
||
ids = append(ids, l.ServerID)
|
||
}
|
||
s.reconcileAll(ids)
|
||
pending := 0
|
||
for _, l := range s.linksOf(s.a.db, d.ID) {
|
||
if l.PSKPending == 1 {
|
||
pending++
|
||
}
|
||
}
|
||
return jsjson.Object{{Key: "id", Val: d.ID}, {Key: "pending", Val: pending}}
|
||
}
|
||
|
||
func idObj(id int64) jsjson.Object { return jsjson.Object{{Key: "id", Val: id}} }
|
||
|
||
func merge(a, b jsjson.Object) jsjson.Object {
|
||
out := append(jsjson.Object{}, a...)
|
||
for _, kv := range b {
|
||
replaced := false
|
||
for i := range out {
|
||
if out[i].Key == kv.Key {
|
||
out[i].Val, replaced = kv.Val, true
|
||
}
|
||
}
|
||
if !replaced {
|
||
out = append(out, kv)
|
||
}
|
||
}
|
||
return out
|
||
}
|
||
|
||
// ── Роуты панели (/ui/masterkeys, /ui/devices) ──────────────────────────────
|
||
|
||
func (s *Sub) masterKeysRouter() *Router {
|
||
rt := newRouter()
|
||
auditOff := fail(409, "Аудит выключен на этой панели")
|
||
master := func(c *Ctx) (*masterRow, error) { return s.masterFor(s.masterIDOf(c.Params["id"]), nil) }
|
||
|
||
rt.Get("/", func(c *Ctx) bool {
|
||
return c.JSON(200, jsjson.Object{{Key: "enabled", Val: s.key() != nil}, {Key: "tls", Val: s.tlsPin != nil}, {Key: "keys", Val: s.listMasters(nil)}})
|
||
})
|
||
// Аудит серверов (только core): отчёт, внеочередной проход, ручная очистка, настройки.
|
||
rt.Get("/audit", func(c *Ctx) bool { return c.JSON(200, s.auditState()) })
|
||
rt.Post("/audit", aw(func(c *Ctx) (int, any, error) {
|
||
if !s.auditOn {
|
||
return 0, nil, auditOff
|
||
}
|
||
s.auditAll(false)
|
||
return 200, s.auditState(), nil
|
||
}))
|
||
rt.Post("/audit/clean", aw(func(c *Ctx) (int, any, error) {
|
||
if !s.auditOn {
|
||
return 0, nil, auditOff
|
||
}
|
||
s.cleanNow()
|
||
return 200, s.auditState(), nil
|
||
}))
|
||
rt.Put("/audit/settings", aw(func(c *Ctx) (int, any, error) {
|
||
if !s.auditOn {
|
||
return 0, nil, auditOff
|
||
}
|
||
b := c.Obj()
|
||
s.auditMu.Lock()
|
||
next := s.auditSettings
|
||
s.auditMu.Unlock()
|
||
if v, has := b.Get("clean"); has {
|
||
bv, ok := v.(bool)
|
||
if !ok {
|
||
return 0, nil, fail(400, "clean: true или false")
|
||
}
|
||
next.Clean = bv
|
||
}
|
||
if v, has := b.Get("every_h"); has {
|
||
if !isInt(v) || v.(float64) < 1 || v.(float64) > 168 {
|
||
return 0, nil, fail(400, "Период: от 1 до 168 часов")
|
||
}
|
||
next.EveryH = int(v.(float64))
|
||
}
|
||
if v, has := b.Get("max"); has {
|
||
if !isInt(v) || v.(float64) < 1 || v.(float64) > 1000 {
|
||
return 0, nil, fail(400, "Предел: от 1 до 1000")
|
||
}
|
||
next.Max = int(v.(float64))
|
||
}
|
||
s.auditMu.Lock()
|
||
s.auditSettings = next
|
||
s.metaSet("audit_settings", next.json())
|
||
s.auditMu.Unlock()
|
||
return 200, s.auditState(), nil
|
||
}))
|
||
rt.Post("/", aw(func(c *Ctx) (int, any, error) {
|
||
out, err := s.createMaster(c.Body, nil)
|
||
return 201, out, err
|
||
}))
|
||
rt.Patch("/:id", aw(func(c *Ctx) (int, any, error) {
|
||
m, err := master(c)
|
||
if err != nil {
|
||
return 0, nil, err
|
||
}
|
||
out, err := s.updateMaster(m, c.Body, nil)
|
||
return 200, out, err
|
||
}))
|
||
rt.Post("/:id/rotate", aw(func(c *Ctx) (int, any, error) {
|
||
m, err := master(c)
|
||
if err != nil {
|
||
return 0, nil, err
|
||
}
|
||
s.rotateMaster(m)
|
||
return 200, idObj(m.ID), nil
|
||
}))
|
||
rt.Post("/:id/rekey", aw(func(c *Ctx) (int, any, error) {
|
||
m, err := master(c)
|
||
if err != nil {
|
||
return 0, nil, err
|
||
}
|
||
s.rekeyMaster(m)
|
||
return 200, idObj(m.ID), nil
|
||
}))
|
||
rt.Delete("/:id", aw(func(c *Ctx) (int, any, error) {
|
||
m, err := master(c)
|
||
if err != nil {
|
||
return 0, nil, err
|
||
}
|
||
return 200, s.deleteMaster(m), nil
|
||
}))
|
||
rt.Get("/:id/link", aw(func(c *Ctx) (int, any, error) {
|
||
m, err := master(c)
|
||
if err != nil {
|
||
return 0, nil, err
|
||
}
|
||
out, err := s.linkOf(m, c)
|
||
return 200, out, err
|
||
}))
|
||
rt.Get("/:id/devices", aw(func(c *Ctx) (int, any, error) {
|
||
m, err := master(c)
|
||
if err != nil {
|
||
return 0, nil, err
|
||
}
|
||
list, down := s.masterDevices(m)
|
||
return 200, jsjson.Object{{Key: "devices", Val: list}, {Key: "unreachable", Val: intsJSON(down)}}, nil
|
||
}))
|
||
return rt
|
||
}
|
||
|
||
func (s *Sub) devicesRouter() *Router {
|
||
rt := newRouter()
|
||
dev := func(c *Ctx) (*deviceRow, error) { return s.deviceFor(idOf(c.Params["id"]), nil) }
|
||
rt.Delete("/:id", aw(func(c *Ctx) (int, any, error) {
|
||
d, err := dev(c)
|
||
if err != nil {
|
||
return 0, nil, err
|
||
}
|
||
return 200, s.deleteDevice(d), nil
|
||
}))
|
||
rt.Post("/:id/rekey", aw(func(c *Ctx) (int, any, error) {
|
||
d, err := dev(c)
|
||
if err != nil {
|
||
return 0, nil, err
|
||
}
|
||
s.rekeyDevice(d)
|
||
return 200, idObj(d.ID), nil
|
||
}))
|
||
rt.Post("/:id/psk", aw(func(c *Ctx) (int, any, error) {
|
||
d, err := dev(c)
|
||
if err != nil {
|
||
return 0, nil, err
|
||
}
|
||
return 200, s.rotatePsk(d), nil
|
||
}))
|
||
return rt
|
||
}
|
||
|
||
// ── Внешний API: /api/v1/masterkeys (ключ awgk_) ────────────────────────────
|
||
// scopeOf — набор серверов API-ключа запроса. Устройства — вложенными путями, чтобы
|
||
// область проверялась через их мастер-ключ.
|
||
func (s *Sub) apiRouter(scopeOf func(c *Ctx) []int) *Router {
|
||
rt := newRouter()
|
||
scope := func(c *Ctx) []int {
|
||
if sc := scopeOf(c); sc != nil {
|
||
return sc
|
||
}
|
||
return []int{}
|
||
}
|
||
master := func(c *Ctx) (*masterRow, error) { return s.masterFor(s.masterIDOf(c.Params["id"]), scope(c)) }
|
||
device := func(c *Ctx) (*deviceRow, error) {
|
||
m, err := master(c)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return s.deviceFor(idOf(c.Params["device"]), m)
|
||
}
|
||
withLink := func(c *Ctx, m *masterRow, base jsjson.Object) (jsjson.Object, error) {
|
||
l, err := s.linkOf(m, c)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return merge(base, l), nil
|
||
}
|
||
|
||
rt.Get("/", aw(func(c *Ctx) (int, any, error) {
|
||
return 200, jsjson.Object{{Key: "keys", Val: s.listMasters(scope(c))}}, nil
|
||
}))
|
||
rt.Post("/", aw(func(c *Ctx) (int, any, error) {
|
||
if p := s.linkProblem(c); p != "" { // без ссылки ключ внешней программе бесполезен
|
||
return 0, nil, fail(503, p)
|
||
}
|
||
out, err := s.createMaster(c.Body, scope(c))
|
||
if err != nil {
|
||
return 0, nil, err
|
||
}
|
||
m, err := s.masterFor(int64(out.Get2("id").(int64)), nil)
|
||
if err != nil {
|
||
return 0, nil, err
|
||
}
|
||
res, err := withLink(c, m, out)
|
||
return 201, res, err
|
||
}))
|
||
rt.Get("/:id", aw(func(c *Ctx) (int, any, error) {
|
||
m, err := master(c)
|
||
if err != nil {
|
||
return 0, nil, err
|
||
}
|
||
// devices — счётчик, как в списке; сами устройства — в device_list.
|
||
out := s.masterOutByID(m.ID)
|
||
if s.linkProblem(c) != "" {
|
||
out = merge(out, jsjson.Object{{Key: "link", Val: nil}, {Key: "tls", Val: s.tlsPin != nil}})
|
||
} else if out, err = withLink(c, m, out); err != nil {
|
||
return 0, nil, err
|
||
}
|
||
list, _ := s.masterDevices(m)
|
||
return 200, merge(out, jsjson.Object{{Key: "device_list", Val: list}}), nil
|
||
}))
|
||
rt.Patch("/:id", aw(func(c *Ctx) (int, any, error) {
|
||
m, err := master(c)
|
||
if err != nil {
|
||
return 0, nil, err
|
||
}
|
||
out, err := s.updateMaster(m, c.Body, scope(c))
|
||
return 200, out, err
|
||
}))
|
||
rt.Post("/:id/rotate", aw(func(c *Ctx) (int, any, error) {
|
||
m, err := master(c)
|
||
if err != nil {
|
||
return 0, nil, err
|
||
}
|
||
s.rotateMaster(m)
|
||
m2, err := s.masterFor(m.ID, nil)
|
||
if err != nil {
|
||
return 0, nil, err
|
||
}
|
||
out, err := withLink(c, m2, idObj(m.ID))
|
||
return 200, out, err
|
||
}))
|
||
rt.Post("/:id/rekey", aw(func(c *Ctx) (int, any, error) {
|
||
m, err := master(c)
|
||
if err != nil {
|
||
return 0, nil, err
|
||
}
|
||
s.rekeyMaster(m)
|
||
return 200, idObj(m.ID), nil
|
||
}))
|
||
rt.Delete("/:id", aw(func(c *Ctx) (int, any, error) {
|
||
m, err := master(c)
|
||
if err != nil {
|
||
return 0, nil, err
|
||
}
|
||
return 200, s.deleteMaster(m), nil
|
||
}))
|
||
rt.Get("/:id/devices", aw(func(c *Ctx) (int, any, error) {
|
||
m, err := master(c)
|
||
if err != nil {
|
||
return 0, nil, err
|
||
}
|
||
list, _ := s.masterDevices(m)
|
||
return 200, jsjson.Object{{Key: "devices", Val: list}}, nil
|
||
}))
|
||
rt.Delete("/:id/devices/:device", aw(func(c *Ctx) (int, any, error) {
|
||
d, err := device(c)
|
||
if err != nil {
|
||
return 0, nil, err
|
||
}
|
||
return 200, s.deleteDevice(d), nil
|
||
}))
|
||
rt.Post("/:id/devices/:device/rekey", aw(func(c *Ctx) (int, any, error) {
|
||
d, err := device(c)
|
||
if err != nil {
|
||
return 0, nil, err
|
||
}
|
||
s.rekeyDevice(d)
|
||
return 200, idObj(d.ID), nil
|
||
}))
|
||
rt.Post("/:id/devices/:device/psk", aw(func(c *Ctx) (int, any, error) {
|
||
d, err := device(c)
|
||
if err != nil {
|
||
return 0, nil, err
|
||
}
|
||
return 200, s.rotatePsk(d), nil
|
||
}))
|
||
return rt
|
||
}
|
||
|
||
// ── Удаление сервера из реестра ─────────────────────────────────────────────
|
||
|
||
// beforeServerDelete — пока сервером пользуется живой мастер-ключ — нельзя. Иначе сперва
|
||
// сводим его (пиры панели снимутся) — после удаления до него уже не дотянуться. Не вышло
|
||
// (нода не в сети) — удалять только с force.
|
||
func (s *Sub) beforeServerDelete(id int, force bool) *deleteVeto {
|
||
live := strs(s.a.db, "SELECT m.label FROM master_servers s JOIN master_keys m ON m.id = s.master_id WHERE s.server_id = ? AND m.revoked_at IS NULL", id)
|
||
if len(live) > 0 {
|
||
return &deleteVeto{Error: "Сервер в мастер-ключах: " + strings.Join(live, ", ") + " — сначала уберите его оттуда"}
|
||
}
|
||
if s.a.nodes.IsOnline(id) {
|
||
s.reconcile(id)
|
||
}
|
||
waiting := strs(s.a.db, "SELECT m.label FROM master_servers s JOIN master_keys m ON m.id = s.master_id WHERE s.server_id = ? AND m.revoked_at IS NOT NULL", id)
|
||
tombs := s.tombCount(id)
|
||
if len(waiting) == 0 && tombs == 0 || force {
|
||
return nil
|
||
}
|
||
msg := "Сервер не подтвердил, что снял пиров"
|
||
if len(waiting) > 0 {
|
||
msg += " удалённых мастер-ключей (" + strings.Join(waiting, ", ") + ")"
|
||
}
|
||
msg += ". Дождитесь, пока он выйдет на связь, или удалите принудительно — тогда пиры могут остаться на нём (снять: awg-ctrl peers drop)"
|
||
return &deleteVeto{Error: msg, Forcible: true}
|
||
}
|
||
|
||
func (s *Sub) afterServerDelete(id int) {
|
||
s.a.db.Exec("DELETE FROM master_servers WHERE server_id = ?", id)
|
||
s.a.db.Exec("DELETE FROM master_keys WHERE revoked_at IS NOT NULL AND id NOT IN (SELECT master_id FROM master_servers)")
|
||
}
|