maeneko
de8a32ac41
The torrent flag was read inside loops over users rows (users/stats, peers, metrics) and each read queried the config table. SQLite has a single connection here, so the nested query waited for it forever: the first stats request or Prometheus scrape locked awg-ctrl for good, and the panel showed no users and timed out. - the block setting is kept in memory (loaded at start, updated on save), so the flag never touches the database - the set of flagged IPs is taken once before the query, not per row - regression test: collectMetrics must finish with users in the table Panel: a 401 from the panel itself (its JWT not accepted) now returns to the login screen; a 401 relayed from a node's awg-ctrl does not.
311 lines
11 KiB
Go
311 lines
11 KiB
Go
package ctrl
|
||
|
||
import (
|
||
"encoding/json"
|
||
"sort"
|
||
"strings"
|
||
"sync"
|
||
"time"
|
||
)
|
||
|
||
// Блокировка BitTorrent — то же, что sniffing + blackhole в Xray (3x-ui), только в ядре.
|
||
//
|
||
// Решение принимается по первым байтам и один раз на соединение: совпала сигнатура — соединение
|
||
// получает бит в ct mark и дальше режется целиком, в обе стороны. Смотрим только то, что
|
||
// клиенты шлют в интернет (iifname awg1), до NAT, поэтому источник — IP клиента в туннеле.
|
||
//
|
||
// Ловится: DHT (запросы и ответы), UDP-трекеры, начало uTP-соединения, а при поддержке @ih в
|
||
// nft/ядре — ещё открытое TCP-рукопожатие и HTTP-анонс. Не ловится шифрованное рукопожатие
|
||
// (MSE/PE) и HTTPS-трекеры — так же, как у Xray. Но без DHT и трекеров клиенту негде брать пиров.
|
||
//
|
||
// Как и шейпинг, ничего не пишет в awg1.conf: таблица ставится из процесса и идемпотентно.
|
||
// nft-таблица не привязана к интерфейсу (iifname — по имени), поэтому переживает его рестарт;
|
||
// после перезагрузки сервера её возвращает Apply на старте.
|
||
|
||
type TorrentSettings struct {
|
||
Enabled bool `json:"enabled"`
|
||
}
|
||
|
||
type TorrentPeer struct {
|
||
IP string `json:"ip"`
|
||
Name string `json:"name"` // имя пользователя; у sen://-устройства — пусто
|
||
}
|
||
|
||
type TorrentStatus struct {
|
||
Settings TorrentSettings `json:"settings"`
|
||
Active bool `json:"active"` // таблица реально стоит
|
||
TCP bool `json:"tcp"` // проверяется и TCP (нужен @ih: nftables ≥ 1.0, свежее ядро)
|
||
Hits float64 `json:"hits"` // заблокированных попыток с последнего применения
|
||
Seen []TorrentPeer `json:"seen"` // кто пытался за последние torrentSeenTTL
|
||
Error string `json:"error,omitempty"`
|
||
}
|
||
|
||
const (
|
||
torrentTable = "awg_torrent"
|
||
torrentMark = "0x00100000" // свой бит ct mark: чужие биты не трогаем
|
||
torrentSeenTTL = "10m"
|
||
torrentCacheS = 5 * time.Second // /api/users/stats опрашивается часто — nft не дёргаем на каждый
|
||
)
|
||
|
||
// Сигнатуры. @th,64 — начало данных UDP (заголовок 8 байт); @ih,0 — начало данных TCP с учётом опций.
|
||
const torrentUDPRules = `
|
||
udp dport 53 return
|
||
@th,64,96 0x64313a6164323a696432303a jump block
|
||
@th,64,96 0x64313a7264323a696432303a jump block
|
||
@th,64,96 0x000004172710198000000000 jump block
|
||
ct state new udp length >= 28 @th,64,8 0x41 @th,72,8 < 3 @th,128,32 0 jump block`
|
||
|
||
// DHT-запрос «d1:ad2:id20:» и ответ «d1:rd2:id20:» (bencode, ключи отсортированы — «a»/«r» первые);
|
||
// UDP-трекер: protocol_id 0x41727101980 + action connect (0); uTP SYN: тип 4, версия 1 (0x41),
|
||
// расширение 0–2, timestamp_difference 0 — только в новом потоке, где QUIC начинается с длинного
|
||
// заголовка (0xC0+), и не на 53-м порту, чтобы случайный ID DNS-запроса не сошёлся.
|
||
|
||
const torrentTCPRules = `
|
||
@ih,0,128 0x13426974546f7272656e742070726f74 jump block
|
||
@ih,0,112 0x474554202f616e6e6f756e63653f jump block`
|
||
|
||
// «\x13BitTorrent prot» — открытое рукопожатие пиров; «GET /announce?» — HTTP-трекер.
|
||
|
||
type Torrent struct {
|
||
s *Server
|
||
|
||
opMu sync.Mutex // сериализует nft
|
||
|
||
mu sync.Mutex
|
||
enabled bool // копия настройки в памяти: cached() зовут внутри циклов по строкам users, а
|
||
// соединение с SQLite одно — запрос в базу оттуда ждал бы его вечно
|
||
tcp bool
|
||
lastError string
|
||
cacheAt time.Time
|
||
cache map[string]bool
|
||
cacheHits float64
|
||
}
|
||
|
||
func newTorrent(s *Server) *Torrent {
|
||
t := &Torrent{s: s}
|
||
t.enabled = t.Settings().Enabled
|
||
return t
|
||
}
|
||
|
||
func (t *Torrent) Settings() TorrentSettings {
|
||
return TorrentSettings{Enabled: t.s.getCfg("torrentBlock", "0") == "1"}
|
||
}
|
||
|
||
func (t *Torrent) script(tcp bool) string {
|
||
iface := t.s.iface
|
||
var b strings.Builder
|
||
// add+delete в одной транзакции: таблица пересоздаётся атомарно, без окна без правил.
|
||
b.WriteString("\nadd table inet " + torrentTable + "\ndelete table inet " + torrentTable + "\ntable inet " + torrentTable + " {\n")
|
||
b.WriteString(" counter hits {\n }\n")
|
||
b.WriteString(" set seen {\n type ipv4_addr\n flags dynamic, timeout\n timeout " + torrentSeenTTL + "\n }\n")
|
||
b.WriteString(" chain block {\n ct mark set ct mark or " + torrentMark + "\n update @seen { ip saddr }\n counter name \"hits\"\n drop\n }\n")
|
||
b.WriteString(" chain udp_sig {" + torrentUDPRules + "\n }\n")
|
||
if tcp {
|
||
b.WriteString(" chain tcp_sig {" + torrentTCPRules + "\n }\n")
|
||
}
|
||
b.WriteString(" chain forward {\n type filter hook forward priority -10; policy accept;\n")
|
||
b.WriteString(" ct mark and " + torrentMark + " == " + torrentMark + " drop\n")
|
||
b.WriteString(" iifname \"" + iface + "\" meta nfproto ipv4 meta l4proto udp jump udp_sig\n")
|
||
if tcp {
|
||
b.WriteString(" iifname \"" + iface + "\" meta nfproto ipv4 meta l4proto tcp jump tcp_sig\n")
|
||
}
|
||
b.WriteString(" }\n}\n")
|
||
return b.String()
|
||
}
|
||
|
||
func (t *Torrent) applyNow() error {
|
||
if !t.Settings().Enabled {
|
||
t.removeNow()
|
||
return nil
|
||
}
|
||
// Сначала полный набор; старый nft/ядро не знают @ih — тогда без TCP, но UDP (DHT, трекеры,
|
||
// uTP) всё равно режем: это и есть основная часть.
|
||
tcp := true
|
||
err := shExecStdin("nft", []string{"-f", "-"}, t.script(true))
|
||
if err != nil {
|
||
tcp = false
|
||
if err2 := shExecStdin("nft", []string{"-f", "-"}, t.script(false)); err2 != nil {
|
||
return err2
|
||
}
|
||
t.s.log.Warn("torrent: TCP-сигнатуры не поддерживаются, блокируем только UDP", "nft", err.Error())
|
||
}
|
||
t.mu.Lock()
|
||
t.tcp, t.lastError, t.cache = tcp, "", nil
|
||
t.mu.Unlock()
|
||
t.s.log.Info("torrent block applied", "tcp", tcp)
|
||
return nil
|
||
}
|
||
|
||
func (t *Torrent) removeNow() {
|
||
shExec("nft", "delete", "table", "inet", torrentTable)
|
||
t.mu.Lock()
|
||
t.tcp, t.cache = false, nil
|
||
t.mu.Unlock()
|
||
}
|
||
|
||
func (t *Torrent) noteError(err error) {
|
||
t.mu.Lock()
|
||
defer t.mu.Unlock()
|
||
if m := err.Error(); m != t.lastError {
|
||
t.s.log.Warn("torrent: " + m)
|
||
t.lastError = m
|
||
}
|
||
}
|
||
|
||
// Apply не бросает: без nft awg-ctrl должен работать дальше (как шейпинг).
|
||
func (t *Torrent) Apply() {
|
||
t.opMu.Lock()
|
||
err := t.applyNow()
|
||
t.opMu.Unlock()
|
||
if err != nil {
|
||
t.noteError(err)
|
||
}
|
||
}
|
||
|
||
// Update сохраняет и применяет; ошибку отдаёт вызывающему — оператору нужна причина.
|
||
func (t *Torrent) Update(st TorrentSettings) error {
|
||
v := "0"
|
||
if st.Enabled {
|
||
v = "1"
|
||
}
|
||
t.s.setCfg("torrentBlock", v)
|
||
t.mu.Lock()
|
||
t.enabled, t.cache = st.Enabled, nil
|
||
t.mu.Unlock()
|
||
t.opMu.Lock()
|
||
err := t.applyNow()
|
||
t.opMu.Unlock()
|
||
if err != nil {
|
||
t.mu.Lock()
|
||
t.lastError = err.Error()
|
||
t.mu.Unlock()
|
||
}
|
||
return err
|
||
}
|
||
|
||
// read — набор seen и счётчик из ядра. ok=false — таблицы нет.
|
||
func (t *Torrent) read() (seen map[string]bool, hits float64, ok bool) {
|
||
out, err := shExec("nft", "-j", "list", "set", "inet", torrentTable, "seen")
|
||
if err != nil {
|
||
return nil, 0, false
|
||
}
|
||
seen = map[string]bool{}
|
||
var doc struct {
|
||
Nftables []struct {
|
||
Set *struct {
|
||
Elem []json.RawMessage `json:"elem"`
|
||
} `json:"set"`
|
||
Counter *struct {
|
||
Packets float64 `json:"packets"`
|
||
} `json:"counter"`
|
||
} `json:"nftables"`
|
||
}
|
||
if json.Unmarshal([]byte(out), &doc) == nil {
|
||
for _, it := range doc.Nftables {
|
||
if it.Set == nil {
|
||
continue
|
||
}
|
||
// Элемент с таймаутом — {"elem": {"val": "10.9.0.2", ...}}, без него — просто строка.
|
||
for _, raw := range it.Set.Elem {
|
||
var ip string
|
||
if json.Unmarshal(raw, &ip) != nil {
|
||
var e struct {
|
||
Elem struct {
|
||
Val string `json:"val"`
|
||
} `json:"elem"`
|
||
}
|
||
if json.Unmarshal(raw, &e) == nil {
|
||
ip = e.Elem.Val
|
||
}
|
||
}
|
||
if ip != "" {
|
||
seen[ip] = true
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if out, err := shExec("nft", "-j", "list", "counter", "inet", torrentTable, "hits"); err == nil {
|
||
doc.Nftables = nil
|
||
if json.Unmarshal([]byte(out), &doc) == nil {
|
||
for _, it := range doc.Nftables {
|
||
if it.Counter != nil {
|
||
hits = it.Counter.Packets
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return seen, hits, true
|
||
}
|
||
|
||
// cached не трогает базу (только память и nft) — его можно звать где угодно.
|
||
func (t *Torrent) cached() (map[string]bool, float64, bool) {
|
||
t.mu.Lock()
|
||
if !t.enabled {
|
||
t.mu.Unlock()
|
||
return nil, 0, false
|
||
}
|
||
if t.cache != nil && time.Since(t.cacheAt) < torrentCacheS {
|
||
c, h := t.cache, t.cacheHits
|
||
t.mu.Unlock()
|
||
return c, h, true
|
||
}
|
||
t.mu.Unlock()
|
||
seen, hits, ok := t.read()
|
||
if !ok {
|
||
return nil, 0, false
|
||
}
|
||
t.mu.Lock()
|
||
t.cache, t.cacheHits, t.cacheAt = seen, hits, time.Now()
|
||
t.mu.Unlock()
|
||
return seen, hits, true
|
||
}
|
||
|
||
// SeenSet — кто пытался открыть торрент-соединение за последние torrentSeenTTL. Берите его до
|
||
// запроса к базе, а не внутри цикла по строкам: так на открытом курсоре не висит вызов nft.
|
||
func (t *Torrent) SeenSet() map[string]bool {
|
||
seen, _, _ := t.cached()
|
||
out := make(map[string]bool, len(seen))
|
||
for ip := range seen {
|
||
out[ip] = true
|
||
}
|
||
return out
|
||
}
|
||
|
||
// SeenList — IP с меткой «торренты», по порядку; шейпинг держит их в фоновом классе.
|
||
func (t *Torrent) SeenList() []string {
|
||
seen, _, _ := t.cached()
|
||
out := make([]string, 0, len(seen))
|
||
for ip := range seen {
|
||
out = append(out, ip)
|
||
}
|
||
sort.Strings(out)
|
||
return out
|
||
}
|
||
|
||
func (t *Torrent) Status() TorrentStatus {
|
||
st := TorrentStatus{Settings: t.Settings(), Seen: []TorrentPeer{}}
|
||
seen, hits, active := t.cached()
|
||
t.mu.Lock()
|
||
st.TCP, st.Error = t.tcp && active, t.lastError
|
||
t.mu.Unlock()
|
||
st.Active, st.Hits = active, hits
|
||
if len(seen) == 0 {
|
||
return st
|
||
}
|
||
names := map[string]string{}
|
||
if rows, err := t.s.db.Query("SELECT name, ip FROM users"); err == nil {
|
||
for rows.Next() {
|
||
var n, ip string
|
||
if rows.Scan(&n, &ip) == nil {
|
||
names[ip] = n
|
||
}
|
||
}
|
||
rows.Close()
|
||
}
|
||
for ip := range seen {
|
||
st.Seen = append(st.Seen, TorrentPeer{IP: ip, Name: names[ip]})
|
||
}
|
||
sort.Slice(st.Seen, func(i, j int) bool { return st.Seen[i].IP < st.Seen[j].IP })
|
||
return st
|
||
}
|