prod/HY2XS_flamy
5
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 6 Wiki Activity

fix: закрыть каналы утечки секретов и сделать PHASE 1 владением оркестратора

Browse Source 
Hardening-проход перед первой сборкой на Debian. Три из найденного не
воспроизводились ни на одном dry-run и проявились бы только на живом сервере.

Установка

* preflight внутри install вызывался дважды и оба раза проверял clean-host.
  Ко второму вызову на диске лежал собственный /var/lib/hy2xs/install-state.json,
  записанный после первого preflight, и опознавался как маркер посторонней
  установки: КАЖДАЯ чистая установка падала сразу после apt-get с
  fatal_post_apply и оставляла сервер наполовину настроенным. Чистота хоста —
  условие входа в операцию, возможности платформы проверяются уже внутри
  PHASE 1, поэтому checkCleanHost стал отдельным параметром без умолчания.

* PHASE 1 начиналась в install.sh: shell сам создавал /usr/local/lib/hy2xs,
  ставил бинарник, вешал symlink и копировал runtime-пакет, и только потом
  запускал оркестратор с его собственным preflight. Отказ того preflight
  объявлялся fatal_pre_apply — «на сервере ничего не изменено» — при уже
  созданном каталоге оркестратора. Отследить владение мутацией невозможно,
  пока мутируют двое: install.sh больше не изменяет ничего, раскладку
  выполняет steps/bootstrap.ts под ownership.bootstrapTouched, пути попали
  в owned_paths. Как следствие удалено деление clean-host на фазы.

* diagnosticsCollect стояла перед rollback обычным await в install и в
  reconfigure. На заполненном диске она падает сама и отменяла откат целиком.
  Диагностика — best effort, откат — обязателен.

* reconfigure/repair выбирали записываемую фазу отказа регулярным выражением
  по тексту ошибки. Переведено на ownership-флаги.

Секреты

* Журнал админки писал RequestURI, то есть путь вместе с query. Hysteria
  обращается к /internal/hysteria/auth?access_token=<секрет> при каждом
  подключении пира, поэтому действующий machine token оседал открытым текстом
  в hy2xs-admin.log, который отдаётся через ExportLog и попадает в
  diagnostics-бандл. Логируется путь; значения query не пишутся, имена —
  пишутся. Канала было два: gin.Default() печатает path?query в stdout,
  оттуда в journald и в тот же бандл, — панель переведена на gin.New() +
  Recovery(). Журналы внутри бандла и журнал Hysteria из ExportLog теперь
  проходят санитайз. Сравнение токена — constant time.

* Config API позволял прочитать и подменить ключи приложения: getConfig и
  listConfig принимали произвольный ключ, а проверка записи была denylist'ом
  из трёх ключей оркестратора. Запрос ?key=PEER_SECRET_ENCRYPTION_KEY отдавал
  master-key шифрования секретов пиров. Доступ переведён на allowlist, маршрут
  getConfig удалён целиком — потребителей у него не было ни одного.

Пиры

* Импорт применялся по одной записи вне транзакции, вопреки собственному
  контракту. Валидация не знает, что уже лежит в базе: cross-conflict по
  UNIQUE(name) оставлял часть файла применённой. Применение выполняется одной
  транзакцией, криптоматериал считается до её открытия.

* Файл импорта мог содержать хвостовой JSON-документ, который молча не
  применялся. После разбора проверяется io.EOF.

* Экспорт разделён на «Экспорт настроек» и «Резервная копия» с секретами и
  подтверждением: обычный экспорт выдаёт пирам новые секреты при импорте, и
  прежние клиентские ссылки после переноса переставали работать.

Сборка

* Два stale-грепа в приёмке роняли build.sh в самом конце, внутри
  verify_archive. Первый искал в smoke.ts исчезнувший литерал URL, второй
  совпадал с router_test.go, который перечисляет удалённые маршруты, потому
  что проверяет их отсутствие: добавление регрессионного теста ломало сборку.

* verify_archive требовал наличия мутирующей строки в install.sh. Инвариант
  перевёрнут: их не должно быть ни одной.

Очистка

* Удалены entity.LegacyAccount, миграции 002/003 и мёртвые хелперы
  listSQLMigrationFiles и envInt: v1 не мигрирует базу 0.x ни при каком
  сценарии. Номера оставшихся миграций сохранены. H UI-словарь убран из
  обычных доков, в docs/14 он остаётся — там это имена объектов для удаления.

* Список непубличных IPv4 приведён к IANA Special-Purpose Address Registry:
  203.0.113.5 из RFC-примеров считался публичным адресом сервера. Отказ
  резолвера отделён от отсутствия A-записи.

Проверено: bun test 233, go test 71, tsc/vue-tsc, bash -n 11 скриптов,
приёмка прогнана против дерева.
This commit is contained in:
Crimson
2026-08-28 05:27:10 +05:00
parent 5574b7c89a
commit 672d455467
55 changed files with 3161 additions and 582 deletions
Download Patch File Download Diff File Expand all files Collapse all files
apps/cmd/server.go
+15 -1
View File
@@ -76,7 +76,21 @@ func runServer(port string) error {
return err
}
r := gin.Default()
// gin.New(), а не gin.Default().
//
// gin.Default() подключает gin.Logger(), который печатает в stdout путь
// ВМЕСТЕ с query string. Для админки это второй, независимый от logrus
// канал журналирования: stdout юнита уезжает в journald, а diagnostics
// кладёт `journalctl -u hy2xs-admin` в бандл. Пока он существовал,
// machine token из /internal/hysteria/auth?access_token=… утекал в
// журнал даже после того, как из собственного логгера админки query
// string убрали.
//
// HTTP-логгер у продукта ровно один — middleware.LogHandler, и он
// подключается пофазно в router.Router. Здесь остаётся только Recovery:
// паника в обработчике не должна ронять сервис.
r := gin.New()
r.Use(gin.Recovery())
router.Router(r)
// TLS внутри админки не поддерживается намеренно: панель слушает
apps/controller/config.go
+65 -41
View File
@@ -2,29 +2,41 @@ package controller
import (
"fmt"
"sort"
"strings"
"time"
"github.com/gin-gonic/gin"
"hy2xs-admin/model/constant"
"hy2xs-admin/model/dto"
"hy2xs-admin/model/vo"
"hy2xs-admin/service"
"time"
)
// Ключи, которыми владеет install-оркестратор: панель обязана отказать в
// записи, а не молча создать второй источник истины.
// Доступ операторского API к таблице `config` — строго по allowlist.
//
// Сетевых настроек самой панели в этом списке больше нет, потому что их нет
// и в базе: порт и bind приходят из контракта запуска, TLS терминируется
// снаружи. См. model/constant/config.go.
func isOrchestratorManagedConfigKey(key string) bool {
switch key {
case constant.Hysteria2Enable,
constant.Hysteria2Config,
constant.Hysteria2TrafficStatsSecret:
return true
default:
return false
}
// Что было. Проверка работала denylist'ом из трёх orchestrator-ключей, а
// GetConfig/ListConfig принимали произвольную строку. В той же таблице лежат
// JWT_SECRET, PEER_SECRET_KEY, PEER_SECRET_ENCRYPTION_KEY и
// HYSTERIA2_TRAFFIC_STATS_SECRET, поэтому авторизованный запрос
// `?key=PEER_SECRET_ENCRYPTION_KEY` отдавал master-key шифрования секретов
// пиров, а updateConfigs позволял подменить JWT_SECRET и оба peer-ключа.
//
// То есть опасность, ради которой удаляли generic export/import таблицы
// `config`, никуда не делась — она осталась в точечном API.
//
// Список ключей ведётся в model/constant/config.go: там же, где сами ключи, а
// не в слое HTTP.
func denyUnknownConfigKey(key string, allowed []string, operation string, c *gin.Context) {
sort.Strings(allowed)
vo.Fail(
fmt.Sprintf(
"config key %q is not available for %s via API (allowed: %s)",
key, operation, strings.Join(allowed, ", "),
),
c,
)
}
func UpdateConfigs(c *gin.Context) {
@@ -39,11 +51,18 @@ func UpdateConfigs(c *gin.Context) {
key := *item.Key
value := *item.Value
// Отдельное сообщение для ключей, которыми владеет оркестратор: их
// отказ — это не «нет такого ключа», а указание на владельца.
if isOrchestratorManagedConfigKey(key) {
vo.Fail(fmt.Sprintf("%s managed by orchestrator: use hy2xs-orchestrator reconfigure", key), c)
return
}
if !constant.IsPublicWritableConfigKey(key) {
denyUnknownConfigKey(key, constant.PublicWritableConfigKeys(), "write", c)
return
}
if key == constant.ResetTrafficCron {
resetTrafficCron, err := service.GetConfig(constant.ResetTrafficCron)
if err != nil {
@@ -70,38 +89,45 @@ func UpdateConfigs(c *gin.Context) {
vo.Success(nil, c)
}
func GetConfig(c *gin.Context) {
configDto, err := validateField(c, dto.ConfigDto{})
if err != nil {
return
// isOrchestratorManagedConfigKey — ключи, которыми владеет install-оркестратор.
//
// Формально они и так не входят в allowlist, но отказ по ним обязан объяснять
// ПОЧЕМУ: «этим значением владеет оркестратор» — это другой ответ, чем «такого
// ключа в API нет», и он ведёт оператора к `hy2xs-orchestrator reconfigure`.
func isOrchestratorManagedConfigKey(key string) bool {
switch key {
case constant.Hysteria2Enable,
constant.Hysteria2Config,
constant.Hysteria2TrafficStatsSecret:
return true
default:
return false
}
config, err := service.GetConfig(*configDto.Key)
if err != nil {
vo.Fail(err.Error(), c)
return
}
configVo := vo.ConfigVo{
Key: *config.Key,
Value: *config.Value,
}
running := service.Hysteria2IsRunning()
if *config.Key == constant.Hysteria2Enable {
if running {
configVo.Value = "1"
} else {
configVo.Value = "0"
}
}
vo.Success(configVo, c)
}
// Маршрута GET /config/getConfig здесь больше нет.
//
// Он принимал произвольный ключ и был вторым, менее заметным входом в ту же
// таблицу секретов, что и удалённый generic export. При этом ни одного
// потребителя у него не было: панель читает настройки только через listConfig.
// Маршрут не оставлен с фильтром, а удалён — точка входа, которой никто не
// пользуется, не должна существовать.
func ListConfig(c *gin.Context) {
configsDto, err := validateField(c, dto.ConfigsDto{})
if err != nil {
return
}
// Проверка идёт до обращения к базе: отказ не должен зависеть от того,
// существует ли строка с таким ключом.
for _, key := range configsDto.Keys {
if !constant.IsPublicReadableConfigKey(key) {
denyUnknownConfigKey(key, constant.PublicReadableConfigKeys(), "read", c)
return
}
}
configs, err := service.ListConfig(configsDto.Keys)
if err != nil {
vo.Fail(err.Error(), c)
@@ -159,5 +185,3 @@ func ExportHysteria2Config(c *gin.Context) {
// Осмысленного production-сценария у этой пары не было: конфигурацией сервера
// владеет install-оркестратор, перенос пиров делают ImportPeer/ExportPeer, а
// серверный конфиг Hysteria выгружается отдельным санитизирующим маршрутом.
// Поэтому маршруты удалены, а не оставлены с фильтром: список ключей,
// требующий ручного сопровождения, снова разошёлся бы со схемой базы.
apps/controller/config_test.go
+155
View File
@@ -0,0 +1,155 @@
package controller
import (
"bytes"
"encoding/json"
"net/http"
"net/http/httptest"
"strings"
"testing"
"github.com/gin-gonic/gin"
"hy2xs-admin/model/constant"
)
// Секреты, которые лежат в таблице `config` рядом с пользовательскими
// настройками. Каждый из них раньше можно было прочитать через
// GET /api/config/getConfig?key=… и подменить через updateConfigs.
var secretConfigKeys = []string{
constant.JwtSecret,
constant.PeerSecretKey,
constant.PeerSecretEncryptionKey,
constant.Hysteria2TrafficStatsSecret,
}
type apiResult struct {
Code int `json:"code"`
Type string `json:"type"`
Message string `json:"message"`
Data json.RawMessage `json:"data"`
}
func postJSON(t *testing.T, handler gin.HandlerFunc, path string, body any) apiResult {
t.Helper()
gin.SetMode(gin.TestMode)
payload, err := json.Marshal(body)
if err != nil {
t.Fatalf("не удалось собрать тело запроса: %v", err)
}
engine := gin.New()
engine.POST(path, handler)
request := httptest.NewRequest(http.MethodPost, path, bytes.NewReader(payload))
request.Header.Set("Content-Type", "application/json")
recorder := httptest.NewRecorder()
engine.ServeHTTP(recorder, request)
var result apiResult
if err := json.Unmarshal(recorder.Body.Bytes(), &result); err != nil {
t.Fatalf("ответ не разбирается как JSON: %s", recorder.Body.String())
}
return result
}
// Отказ обязан наступать ДО обращения к базе: тест выполняется без
// инициализированного SQLite, и любой поход в dao здесь уронил бы обработчик.
// Это и есть доказательство того, что проверка стоит на входе.
func TestListConfigRefusesInternalKeys(t *testing.T) {
for _, key := range secretConfigKeys {
result := postJSON(t, ListConfig, "/config/listConfig", map[string]any{"keys": []string{key}})
if result.Type != "no" {
t.Errorf("чтение %s не отклонено: %+v", key, result)
}
if !strings.Contains(result.Message, "not available for read") {
t.Errorf("невнятный отказ для %s: %s", key, result.Message)
}
}
}
// Секретный ключ, спрятанный среди разрешённых, обязан отклонить весь запрос.
func TestListConfigRefusesMixedBatch(t *testing.T) {
result := postJSON(t, ListConfig, "/config/listConfig", map[string]any{
"keys": []string{constant.Hysteria2TrafficTime, constant.PeerSecretEncryptionKey},
})
if result.Type != "no" {
t.Fatalf("смешанная партия не отклонена: %+v", result)
}
if len(result.Data) != 0 && string(result.Data) != "null" {
t.Fatalf("отказ вернул данные: %s", string(result.Data))
}
}
func TestListConfigRefusesUnknownKey(t *testing.T) {
result := postJSON(t, ListConfig, "/config/listConfig", map[string]any{
"keys": []string{"TOTALLY_UNKNOWN_KEY"},
})
if result.Type != "no" {
t.Fatalf("неизвестный ключ не отклонён: %+v", result)
}
}
func TestUpdateConfigsRefusesInternalKeys(t *testing.T) {
for _, key := range secretConfigKeys {
result := postJSON(t, UpdateConfigs, "/config/updateConfigs", map[string]any{
"configUpdateDtos": []map[string]string{{"key": key, "value": "attacker-controlled"}},
})
if result.Type != "no" {
t.Errorf("запись %s не отклонена: %+v", key, result)
}
}
}
// Ключи оркестратора отклоняются с указанием владельца, а не общим «нет
// такого ключа»: оператор должен понять, что менять их надо через reconfigure.
func TestUpdateConfigsPointsAtOrchestratorForItsOwnKeys(t *testing.T) {
for _, key := range []string{
constant.Hysteria2Enable,
constant.Hysteria2Config,
constant.Hysteria2TrafficStatsSecret,
} {
result := postJSON(t, UpdateConfigs, "/config/updateConfigs", map[string]any{
"configUpdateDtos": []map[string]string{{"key": key, "value": "x"}},
})
if result.Type != "no" {
t.Errorf("запись %s не отклонена: %+v", key, result)
}
if !strings.Contains(result.Message, "hy2xs-orchestrator reconfigure") {
t.Errorf("отказ по %s не называет владельца: %s", key, result.Message)
}
}
}
func TestUpdateConfigsRefusesUnknownKey(t *testing.T) {
result := postJSON(t, UpdateConfigs, "/config/updateConfigs", map[string]any{
"configUpdateDtos": []map[string]string{{"key": "TOTALLY_UNKNOWN_KEY", "value": "x"}},
})
if result.Type != "no" {
t.Fatalf("неизвестный ключ не отклонён: %+v", result)
}
if !strings.Contains(result.Message, "not available for write") {
t.Fatalf("невнятный отказ: %s", result.Message)
}
}
// Отказ на любой записи партии обязан отменить партию целиком: иначе первые
// ключи применились бы, а оператор получил бы ошибку.
func TestUpdateConfigsRefusesWholeBatchOnFirstForbiddenKey(t *testing.T) {
result := postJSON(t, UpdateConfigs, "/config/updateConfigs", map[string]any{
"configUpdateDtos": []map[string]string{
{"key": constant.JwtSecret, "value": "attacker-controlled"},
{"key": constant.Hysteria2TrafficTime, "value": "10"},
},
})
if result.Type != "no" {
t.Fatalf("партия с секретом не отклонена: %+v", result)
}
}
apps/controller/peer.go
+13
View File
@@ -178,6 +178,19 @@ func ImportPeer(c *gin.Context) {
return
}
// json.Decoder читает ПЕРВЫЙ документ и останавливается. Файл вида
//
// [{"name":"peer"}]
// {"что-то":"ещё"}
//
// принимался целиком, а хвост просто не читался: оператор видел «импорт
// выполнен» и не узнавал, что применилась половина файла. Файл обязан
// содержать ровно один JSON-документ.
if err = decoder.Decode(&struct{}{}); err != io.EOF {
vo.Fail("json file must contain exactly one JSON document", c)
return
}
if err = service.UpsertPeerExport(peerExports); err != nil {
vo.Fail(err.Error(), c)
return
apps/controller/peer_test.go
+122
View File
@@ -0,0 +1,122 @@
package controller
import (
"bytes"
"encoding/json"
"mime/multipart"
"net/http"
"net/http/httptest"
"path/filepath"
"strings"
"testing"
"github.com/gin-gonic/gin"
"hy2xs-admin/dao"
)
// Разбор загруженного файла проверяется без базы: все три отказа наступают до
// первого обращения к слою данных, и это часть контракта — испорченный файл не
// должен доходить до транзакции.
func postImportFile(t *testing.T, fileName string, content string) apiResult {
t.Helper()
gin.SetMode(gin.TestMode)
body := &bytes.Buffer{}
writer := multipart.NewWriter(body)
part, err := writer.CreateFormFile("file", fileName)
if err != nil {
t.Fatalf("не удалось собрать форму: %v", err)
}
if _, err := part.Write([]byte(content)); err != nil {
t.Fatalf("не удалось записать файл в форму: %v", err)
}
if err := writer.Close(); err != nil {
t.Fatalf("не удалось закрыть форму: %v", err)
}
engine := gin.New()
engine.POST("/peer-import", ImportPeer)
request := httptest.NewRequest(http.MethodPost, "/peer-import", body)
request.Header.Set("Content-Type", writer.FormDataContentType())
recorder := httptest.NewRecorder()
engine.ServeHTTP(recorder, request)
var result apiResult
if err := json.Unmarshal(recorder.Body.Bytes(), &result); err != nil {
t.Fatalf("ответ не разбирается как JSON: %s", recorder.Body.String())
}
return result
}
// Регрессия: json.Decoder читает ПЕРВЫЙ документ и останавливается. Файл с
// хвостом принимался целиком, оператор видел «импорт выполнен», а вторая
// половина файла молча не применялась.
func TestImportPeerRejectsTrailingDocument(t *testing.T) {
result := postImportFile(t, "peers.json", `[{"name":"alpha1"}]
{"name":"ignored"}`)
if result.Type != "no" {
t.Fatalf("файл с хвостовым документом не отклонён: %+v", result)
}
if !strings.Contains(result.Message, "exactly one JSON document") {
t.Fatalf("невнятный отказ: %s", result.Message)
}
}
func TestImportPeerRejectsTrailingGarbage(t *testing.T) {
for _, content := range []string{
"[{\"name\":\"alpha1\"}] trailing",
"[{\"name\":\"alpha1\"}][{\"name\":\"bravo2\"}]",
"[{\"name\":\"alpha1\"}]\n[]",
} {
result := postImportFile(t, "peers.json", content)
if result.Type != "no" {
t.Errorf("файл %q не отклонён: %+v", content, result)
}
}
}
func TestImportPeerRejectsUnknownFields(t *testing.T) {
result := postImportFile(t, "peers.json", `[{"name":"alpha1","totallyUnknown":1}]`)
if result.Type != "no" {
t.Fatalf("неизвестное поле не отклонено: %+v", result)
}
}
func TestImportPeerRejectsNonJsonFileName(t *testing.T) {
result := postImportFile(t, "peers.txt", `[{"name":"alpha1"}]`)
if result.Type != "no" {
t.Fatalf("файл не с расширением .json не отклонён: %+v", result)
}
}
// Положительный путь целиком: корректный одиночный документ обязан не только
// разобраться, но и доехать до базы. Без него проверки выше доказывали бы
// только то, что отклоняется всё подряд.
func TestImportPeerAcceptsSingleDocument(t *testing.T) {
dbPath := filepath.Join(t.TempDir(), "hy2xs-admin-test.db")
if err := dao.InitSqliteDBAt(dbPath); err != nil {
t.Fatalf("не удалось открыть тестовую базу: %v", err)
}
if err := dao.RunMigrations(); err != nil {
t.Fatalf("не удалось применить миграции: %v", err)
}
t.Cleanup(func() { _ = dao.CloseSqliteDB() })
result := postImportFile(t, "peers.json", `[{"name":"alpha1","quotaBytes":-1,"maxDevices":3}]`)
if result.Type != "ok" {
t.Fatalf("корректный файл отклонён: %+v", result)
}
peers, err := dao.ListPeer("name = ?", "alpha1")
if err != nil {
t.Fatalf("не удалось прочитать пиров: %v", err)
}
if len(peers) != 1 {
t.Fatalf("импорт не создал пира: найдено %d", len(peers))
}
}
apps/dao/peer.go
+79 -26
View File
@@ -11,14 +11,91 @@ import (
"time"
)
func SavePeer(peer entity.Peer) (int64, error) {
if tx := sqliteDB.Save(&peer); tx.Error != nil {
// PeerTx — операции над пирами в границах одной единицы работы.
//
// Интерфейс существует, чтобы транзакция была доступна слою service, но
// *gorm.DB туда не протекал: выбор ORM остаётся деталью dao. Реализация одна и
// та же и для глобального соединения, и для транзакции — за счёт этого
// невозможна ситуация, когда «обычный» путь и «транзакционный» расходятся в
// поведении.
type PeerTx interface {
GetPeer(query interface{}, args ...interface{}) (entity.Peer, error)
SavePeer(peer entity.Peer) (int64, error)
UpdatePeer(ids []int64, updates map[string]interface{}) error
}
type peerTx struct {
db *gorm.DB
}
// WithPeerTx выполняет fn в одной транзакции: либо применяются все записи,
// либо ни одной.
//
// Что было. Импорт пиров валидировал партию целиком до первой записи, но сами
// записи шли по одной, каждая своим оператором. Комментарий обещал «либо
// целиком, либо никак», а на практике UNIQUE-конфликт на 37-й записи оставлял
// 36 применённых. Конфликт при этом совершенно реальный: если в базе есть
// A(auth_id=a, name=alice) и B(auth_id=b, name=bob), а импорт несёт
// (auth_id=a, name=bob), то поиск найдёт A по auth_id и попытается
// переименовать его в bob — прямо в UNIQUE(name).
func WithPeerTx(fn func(tx PeerTx) error) error {
if sqliteDB == nil {
return errors.New("sqlite is not initialized")
}
return sqliteDB.Transaction(func(tx *gorm.DB) error {
return fn(peerTx{db: tx})
})
}
func (p peerTx) SavePeer(peer entity.Peer) (int64, error) {
if tx := p.db.Save(&peer); tx.Error != nil {
logrus.Errorf("%v", tx.Error)
return 0, errors.New(constant.SysError)
}
return *peer.Id, nil
}
func (p peerTx) UpdatePeer(ids []int64, updates map[string]interface{}) error {
if len(updates) == 0 {
return nil
}
updates["update_time"] = time.Now().Format("2006-01-02 15:04:05")
if tx := p.db.Model(&entity.Peer{}).Where("id in ?", ids).Updates(updates); tx.Error != nil {
logrus.Errorf("%v", tx.Error)
return errors.New(constant.SysError)
}
return nil
}
func (p peerTx) GetPeer(query interface{}, args ...interface{}) (entity.Peer, error) {
var peer entity.Peer
if tx := p.db.Model(&entity.Peer{}).Where(query, args...).First(&peer); tx.Error != nil {
if tx.Error == gorm.ErrRecordNotFound {
return peer, errors.New(constant.WrongPassword)
}
logrus.Errorf("%v", tx.Error)
return peer, errors.New(constant.SysError)
}
return peer, nil
}
// global — операции вне транзакции. Одна и та же реализация, другое соединение.
func global() peerTx {
return peerTx{db: sqliteDB}
}
func SavePeer(peer entity.Peer) (int64, error) {
return global().SavePeer(peer)
}
func UpdatePeer(ids []int64, updates map[string]interface{}) error {
return global().UpdatePeer(ids, updates)
}
func GetPeer(query interface{}, args ...interface{}) (entity.Peer, error) {
return global().GetPeer(query, args...)
}
func DeletePeer(ids []int64) error {
if tx := sqliteDB.Where("id in ?", ids).Delete(&entity.Peer{}); tx.Error != nil {
logrus.Errorf("%v", tx.Error)
@@ -27,30 +104,6 @@ func DeletePeer(ids []int64) error {
return nil
}
func UpdatePeer(ids []int64, updates map[string]interface{}) error {
if len(updates) == 0 {
return nil
}
updates["update_time"] = time.Now().Format("2006-01-02 15:04:05")
if tx := sqliteDB.Model(&entity.Peer{}).Where("id in ?", ids).Updates(updates); tx.Error != nil {
logrus.Errorf("%v", tx.Error)
return errors.New(constant.SysError)
}
return nil
}
func GetPeer(query interface{}, args ...interface{}) (entity.Peer, error) {
var peer entity.Peer
if tx := sqliteDB.Model(&entity.Peer{}).Where(query, args...).First(&peer); tx.Error != nil {
if tx.Error == gorm.ErrRecordNotFound {
return peer, errors.New(constant.WrongPassword)
}
logrus.Errorf("%v", tx.Error)
return peer, errors.New(constant.SysError)
}
return peer, nil
}
func ListPeer(query interface{}, args ...interface{}) ([]entity.Peer, error) {
var peers []entity.Peer
if tx := sqliteDB.Model(&entity.Peer{}).Where(query, args...).Order("create_time desc").Find(&peers); tx.Error != nil {
apps/dao/sqlite.go
+31 -167
View File
@@ -3,7 +3,6 @@ package dao
import (
"encoding/base64"
"errors"
"fmt"
"github.com/glebarez/sqlite"
"github.com/sirupsen/logrus"
"gorm.io/gorm"
@@ -14,9 +13,6 @@ import (
"hy2xs-admin/util"
"log"
"os"
"path/filepath"
"sort"
"strconv"
"strings"
"time"
)
@@ -24,8 +20,17 @@ import (
var sqliteDB *gorm.DB
func InitSqliteDB() error {
return InitSqliteDBAt(constant.SqliteDBPath)
}
// InitSqliteDBAt открывает базу по указанному пути.
//
// Путь параметризован, а не зашит: без этого единственным способом проверить
// поведение слоя данных (транзакционность импорта пиров, в первую очередь)
// было бы обращение к реальной /var/lib/hy2xs-admin/hy2xs-admin.db.
func InitSqliteDBAt(path string) error {
var err error
sqliteDB, err = gorm.Open(sqlite.Open(constant.SqliteDBPath), &gorm.Config{
sqliteDB, err = gorm.Open(sqlite.Open(path), &gorm.Config{
TranslateError: true,
Logger: logger.New(
log.New(os.Stdout, "\r\n", log.LstdFlags),
@@ -76,15 +81,6 @@ func InitSql() error {
return nil
}
func envInt(name string, fallback int) int {
if raw := strings.TrimSpace(os.Getenv(name)); raw != "" {
if value, err := strconv.Atoi(raw); err == nil {
return value
}
}
return fallback
}
func envBoolAsInt(name string, fallback int) int {
raw := strings.TrimSpace(strings.ToLower(os.Getenv(name)))
if raw == "" {
@@ -264,6 +260,15 @@ func getOrCreateConfigKey(key string, size int) (string, error) {
return value, nil
}
// RunMigrations приводит схему базы к текущему поколению.
//
// Экспортирована, чтобы схему можно было поднять отдельно от InitSql: тестам
// слоя данных нужна таблица, но не нужны bootstrap-администратор, bootstrap-пир
// и генерация JWT-секрета.
func RunMigrations() error {
return runMigrations()
}
func runMigrations() error {
if tx := sqliteDB.Exec(`CREATE TABLE IF NOT EXISTS schema_migrations (
version TEXT PRIMARY KEY,
@@ -278,11 +283,21 @@ func runMigrations() error {
apply func() error
}
// Миграций 002_migrate_legacy_accounts и 003_archive_legacy_account здесь
// больше нет.
//
// Они переносили таблицу `account` предыдущего поколения в admin_user/peer
// и переименовывали её в бэкап. Это compatibility-слой продукта, который
// HY2XS v1 принципиально не поддерживает: установка возможна только на
// чистый хост, база 0.x не мигрируется ни при каком сценарии, а clean-host
// контракт отказывает ещё до создания базы. Живого пути, по которому такая
// таблица могла бы оказаться в hy2xs-admin.db, не существует.
//
// Номера оставшихся миграций сохранены: перенумерация заставила бы их
// примениться повторно на уже установленных машинах.
migrations := []migration{
{version: "000_base_config", apply: migrateBaseConfig},
{version: "001_admin_peer_split", apply: migrateAdminPeerSplit},
{version: "002_migrate_legacy_accounts", apply: migrateLegacyAccounts},
{version: "003_archive_legacy_account", apply: archiveLegacyAccount},
{version: "004_traffic_samples_and_aggregates", apply: migrateTrafficTables},
{version: "005_metric_sample", apply: migrateMetricSampleTable},
}
@@ -403,125 +418,6 @@ func migrateAdminPeerSplit() error {
return nil
}
func migrateLegacyAccounts() error {
if !tableExists("account") {
return nil
}
var accounts []entity.LegacyAccount
if tx := sqliteDB.Model(&entity.LegacyAccount{}).Order("id asc").Find(&accounts); tx.Error != nil {
logrus.Errorf("sqlite legacy account query err: %v", tx.Error)
return errors.New("sqlite legacy account query err")
}
nowMs := time.Now().UnixMilli()
for _, acc := range accounts {
if acc.Role != nil && *acc.Role == "admin" {
if acc.Username == nil || acc.Pass == nil {
continue
}
_, getErr := GetAdminUser("username = ?", *acc.Username)
if getErr == nil {
continue
}
status := int64(1)
if acc.Deleted != nil && *acc.Deleted == 1 {
status = 0
}
lastLogin := int64(0)
if acc.LoginAt != nil {
lastLogin = *acc.LoginAt
}
passwordChangedAt := nowMs
admin := entity.AdminUser{
Username: acc.Username,
PasswordHash: acc.Pass,
Status: &status,
ForcePasswordChange: acc.ForcePasswordChange,
LastLoginAt: &lastLogin,
PasswordChangedAt: &passwordChangedAt,
TokenVersion: func() *int64 { v := int64(1); return &v }(),
}
if _, saveErr := SaveAdminUser(admin); saveErr != nil {
return saveErr
}
continue
}
if acc.Username == nil || acc.ConPass == nil {
continue
}
_, getPeerErr := GetPeer("name = ?", *acc.Username)
if getPeerErr == nil {
continue
}
authId, authErr := util.RandomString(18)
if authErr != nil {
return authErr
}
peerSecretKey, keyErr := getOrCreatePeerSecretDigestKey()
if keyErr != nil {
return keyErr
}
secretDigest := util.HmacSHA256Hex(*acc.ConPass, peerSecretKey)
secretEncrypted := *acc.ConPass
quota := int64(0)
if acc.Quota != nil {
quota = *acc.Quota
}
download := int64(0)
if acc.Download != nil {
download = *acc.Download
}
upload := int64(0)
if acc.Upload != nil {
upload = *acc.Upload
}
expires := int64(0)
if acc.ExpireTime != nil {
expires = *acc.ExpireTime
}
maxDevices := int64(3)
if acc.DeviceNo != nil {
maxDevices = *acc.DeviceNo
}
disabled := int64(0)
if acc.Deleted != nil {
disabled = *acc.Deleted
}
bannedUntil := int64(0)
if acc.KickUtilTime != nil {
bannedUntil = *acc.KickUtilTime
}
lastConnection := int64(0)
if acc.ConAt != nil {
lastConnection = *acc.ConAt
}
remark := ""
if acc.Remark != nil {
remark = *acc.Remark
}
peer := entity.Peer{
Name: acc.Username,
Remark: &remark,
AuthId: &authId,
SecretDigest: &secretDigest,
SecretEncrypted: &secretEncrypted,
QuotaBytes: &quota,
DownloadBytes: &download,
UploadBytes: &upload,
ExpiresAt: &expires,
MaxDevices: &maxDevices,
Disabled: &disabled,
BannedUntil: &bannedUntil,
LastConnectionAt: &lastConnection,
}
if _, saveErr := SavePeer(peer); saveErr != nil {
return saveErr
}
}
return nil
}
func getOrCreateJwtSecret() (string, error) {
if existing, err := GetConfig("key = ?", constant.JwtSecret); err == nil {
if existing.Value != nil && strings.TrimSpace(*existing.Value) != "" {
@@ -562,18 +458,6 @@ func getOrCreatePeerSecretDigestKey() (string, error) {
return keyValue, nil
}
func archiveLegacyAccount() error {
if !tableExists("account") {
return nil
}
backupName := fmt.Sprintf("legacy_account_backup_%d", time.Now().Unix())
if tx := sqliteDB.Exec("ALTER TABLE account RENAME TO " + backupName); tx.Error != nil {
logrus.Errorf("sqlite legacy archive err: %v", tx.Error)
return errors.New("sqlite legacy archive err")
}
return nil
}
func migrateTrafficTables() error {
stmts := []string{
`CREATE TABLE IF NOT EXISTS traffic_sample (
@@ -658,26 +542,6 @@ func tableExists(tableName string) bool {
}
return count > 0
}
func listSQLMigrationFiles(dir string) ([]string, error) {
entries, err := os.ReadDir(dir)
if err != nil {
return nil, err
}
files := make([]string, 0)
for _, entry := range entries {
if entry.IsDir() {
continue
}
name := entry.Name()
if strings.HasSuffix(strings.ToLower(name), ".sql") {
files = append(files, filepath.Join(dir, name))
}
}
sort.Strings(files)
return files, nil
}
func ensureTrafficStatsSecret() error {
envSecret := strings.TrimSpace(os.Getenv("HY2XS_HYSTERIA_TRAFFIC_STATS_SECRET"))
if envSecret != "" {
apps/frontend/src/api/config/index.ts
+4 -9
View File
@@ -1,7 +1,6 @@
import { AxiosPromise } from "axios";
import request from "@/utils/request";
import {
ConfigDto,
ConfigsDto,
ConfigUpdateDto,
ConfigVo,
@@ -14,6 +13,10 @@ import {
//
// Generic-выгрузки таблицы `config` здесь тоже нет: она отдавала JWT- и
// peer-ключи в открытом виде. Перенос пиров делают ImportPeer/ExportPeer.
//
// getConfigApi удалён вместе с маршрутом: он принимал произвольный ключ той же
// таблицы и не вызывался ни из одного экрана. Чтение настроек идёт через
// listConfigApi, на стороне сервера — по allowlist.
export function getHysteria2ConfigApi(): AxiosPromise<Hysteria2ServerConfig> {
return request({
@@ -22,14 +25,6 @@ export function getHysteria2ConfigApi(): AxiosPromise<Hysteria2ServerConfig> {
});
}
export function getConfigApi(data: ConfigDto): AxiosPromise<ConfigVo> {
return request({
url: "/config/getConfig",
method: "get",
params: data,
});
}
export function listConfigApi(data: ConfigsDto): AxiosPromise<Array<ConfigVo>> {
return request({
url: "/config/listConfig",
apps/frontend/src/api/config/types.ts
+2 -3
View File
@@ -1,6 +1,5 @@
export interface ConfigDto {
key: string;
}
// ConfigDto удалён вместе с маршрутом getConfig: чтение произвольного ключа
// таблицы `config` было входом к JWT- и peer-ключам.
export interface ConfigsDto {
keys: Array<string>;
apps/frontend/src/api/log/types.ts
+5 -1
View File
@@ -12,7 +12,11 @@ export interface LogSystemVo {
level: string;
msg: string;
reqMethod: string;
reqUri: string;
// Путь без query string: в query по машинному endpoint'у приезжает
// действующий machine token, и в журнале его быть не должно.
reqPath: string;
// Только имена переданных query-параметров, без значений.
reqQueryKeys: string;
statusCode: string;
time: string;
}
apps/frontend/src/api/peer/index.ts
+17 -1
View File
@@ -89,10 +89,26 @@ export function importPeerApi(data: FormData): AxiosPromise {
});
}
export function exportPeerApi(): AxiosPromise {
/**
* Экспорт пиров в двух режимах, и это продуктовое различие, а не флаг.
*
* Без секретов — список настроек пиров. Файл безопасно хранить, но при импорте
* на другой сервер записям с пустым секретом выдаются НОВЫЕ секреты, то есть
* прежние клиентские ссылки перестают работать.
*
* С секретами — резервная копия, сохраняющая работоспособность существующих
* ссылок. Файл содержит действующие учётные данные доступа, поэтому запускается
* только через явное подтверждение оператора.
*
* Раньше кнопка была одна и всегда звала маршрут без includeSecrets, а
* документация называла эту пару механизмом переноса пиров. Оператор
* переносил пиров и обнаруживал, что все клиенты отвалились.
*/
export function exportPeerApi(includeSecrets = false): AxiosPromise {
return request({
url: "/peer-export",
method: "post",
params: includeSecrets ? { includeSecrets: "true" } : undefined,
responseType: "blob",
});
}
apps/frontend/src/lang/package/en.ts
+7
View File
@@ -150,6 +150,13 @@ export default {
unlimited: "Unlimited",
secretRotateConfirm:
"Rotate peer secret? Existing client configurations will stop working until updated.",
exportSettings: "Export settings",
exportBackup: "Backup",
exportSettingsHint:
"Peer list without secrets. Safe to store and share, but after importing on another server the peers get new secrets, so existing client links stop working.",
exportBackupConfirm:
"A backup contains the LIVE connection secrets of every peer in plain text: anyone who gets this file gets VPN access. Treat it like a password and delete it once the migration is done. Only this kind of copy keeps existing client links working after moving to another server.",
exportBackupConfirmButton: "I understand, download with secrets",
quota: "Quota",
download: "Download",
upload: "Upload",
apps/frontend/src/lang/package/ru.ts
+7
View File
@@ -146,6 +146,13 @@ export default {
unlimited: "Безлимит",
secretRotateConfirm:
"Сменить секрет пира? Текущие клиентские конфиги перестанут работать до обновления.",
exportSettings: "Экспорт настроек",
exportBackup: "Резервная копия",
exportSettingsHint:
"Список пиров без секретов. Безопасно хранить и передавать, но после импорта на другой сервер пирам будут выданы новые секреты, и прежние клиентские ссылки работать не будут.",
exportBackupConfirm:
"Резервная копия содержит ДЕЙСТВУЮЩИЕ секреты подключения всех пиров в открытом виде: любой, кто получит этот файл, получит доступ к VPN. Храните его как пароль и удалите, когда перенос завершён. Только такая копия сохраняет работоспособность существующих клиентских ссылок после переноса на другой сервер.",
exportBackupConfirmButton: "Понимаю, скачать копию с секретами",
quota: "Квота",
download: "Скачано",
upload: "Отдано",
apps/frontend/src/views/peer/list/index.vue
+32 -5
View File
@@ -30,9 +30,14 @@
>
<el-button>{{ $t("common.import") }}</el-button>
</el-upload>
<el-button class="ml-2" @click="handleExport">{{
$t("common.export")
}}</el-button>
<el-tooltip :content="$t('peer.exportSettingsHint')" placement="bottom">
<el-button class="ml-2" @click="handleExport">{{
$t("peer.exportSettings")
}}</el-button>
</el-tooltip>
<el-button class="ml-2" type="warning" plain @click="handleExportBackup">
{{ $t("peer.exportBackup") }}
</el-button>
</div>
<el-table v-loading="loading" :data="records">
<el-table-column :label="$t('peer.name')" min-width="220">
@@ -558,9 +563,9 @@ function beforeImport(file: UploadRawFile) {
return true;
}
async function handleExport() {
async function downloadExport(includeSecrets: boolean) {
try {
const response = await exportPeerApi();
const response = await exportPeerApi(includeSecrets);
const blob = new Blob([response.data], {
type: "application/octet-stream",
});
@@ -578,6 +583,28 @@ async function handleExport() {
}
}
// Обычный экспорт: настройки пиров без секретов.
async function handleExport() {
await downloadExport(false);
}
// Резервная копия: файл содержит действующие секреты подключения всех пиров.
// Подтверждение здесь обязательно — это единственное место в панели, где
// оператор осознанно выгружает наружу работающие учётные данные доступа.
async function handleExportBackup() {
await ElMessageBox.confirm(
t("peer.exportBackupConfirm"),
t("common.securityRisk"),
{
type: "warning",
confirmButtonText: t("peer.exportBackupConfirmButton"),
cancelButtonText: t("common.cancel"),
confirmButtonClass: "el-button--danger",
}
);
await downloadExport(true);
}
onMounted(handleQuery);
</script>
apps/middleware/log.go
+46 -4
View File
@@ -1,11 +1,14 @@
package middleware
import (
"sort"
"strings"
"time"
"github.com/gin-gonic/gin"
"github.com/sirupsen/logrus"
"gopkg.in/natefinch/lumberjack.v2"
"hy2xs-admin/model/constant"
"time"
)
func InitLog() {
@@ -21,6 +24,40 @@ func InitLog() {
logrus.SetLevel(logrus.InfoLevel)
}
// requestQueryKeys возвращает ИМЕНА query-параметров запроса, без значений.
//
// Для диагностики важно, был ли параметр передан, а не что в нём лежало.
// Список сортируется, чтобы одинаковые запросы давали одинаковую строку в
// логе и её можно было группировать.
func requestQueryKeys(c *gin.Context) string {
query := c.Request.URL.Query()
if len(query) == 0 {
return ""
}
keys := make([]string, 0, len(query))
for key := range query {
keys = append(keys, key)
}
sort.Strings(keys)
return strings.Join(keys, ",")
}
// LogHandler пишет журнал HTTP-запросов админки.
//
// В лог попадает ПУТЬ, а не RequestURI.
//
// Разница здесь не косметическая. RequestURI включает query string, а Hysteria
// обращается к машинному endpoint'у как
// /internal/hysteria/auth?access_token=<machine token> — то есть при каждом
// подключении пира. Пока логировался RequestURI, действующий machine token
// оседал открытым текстом в /var/log/hy2xs/hy2xs-admin.log, а этот файл
// отдаётся оператору через ExportLog и попадает в diagnostics-бандл.
// Получался постоянный канал утечки секрета в обычной штатной работе, мимо
// всей структурной редакции, сделанной для конфигов и env.
//
// Значения query-параметров не логируются вовсе: список того, «что можно», при
// таком подходе пришлось бы поддерживать вручную и он неизбежно разошёлся бы с
// набором маршрутов. Имена параметров сохранены — их для диагностики хватает.
func LogHandler() gin.HandlerFunc {
return func(c *gin.Context) {
startTime := time.Now()
@@ -30,13 +67,18 @@ func LogHandler() gin.HandlerFunc {
statusCode := c.Writer.Status()
latencyTime := time.Since(startTime)
entry := logrus.WithFields(logrus.Fields{
fields := logrus.Fields{
"statusCode": statusCode,
"latencyTime": latencyTime.Milliseconds(),
"clientIP": c.ClientIP(),
"reqMethod": c.Request.Method,
"reqUri": c.Request.RequestURI,
})
"reqPath": c.Request.URL.Path,
}
if keys := requestQueryKeys(c); keys != "" {
fields["reqQueryKeys"] = keys
}
entry := logrus.WithFields(fields)
if statusCode >= 500 {
entry.Error()
apps/middleware/log_test.go
+105
View File
@@ -0,0 +1,105 @@
package middleware
import (
"bytes"
"net/http"
"net/http/httptest"
"strings"
"testing"
"github.com/gin-gonic/gin"
"github.com/sirupsen/logrus"
)
// sentinel имитирует действующий machine token: если он окажется в журнале —
// значит секрет утёк в /var/log/hy2xs/hy2xs-admin.log, который отдаётся
// оператору через ExportLog и попадает в diagnostics-бандл.
const sentinel = "SUPER_SECRET_SENTINEL"
func captureLog(t *testing.T, request *http.Request) string {
t.Helper()
previousOut := logrus.StandardLogger().Out
previousFormatter := logrus.StandardLogger().Formatter
t.Cleanup(func() {
logrus.SetOutput(previousOut)
logrus.SetFormatter(previousFormatter)
})
buffer := &bytes.Buffer{}
logrus.SetOutput(buffer)
logrus.SetFormatter(&logrus.JSONFormatter{})
gin.SetMode(gin.TestMode)
engine := gin.New()
engine.Use(LogHandler())
engine.POST("/internal/hysteria/auth", func(c *gin.Context) { c.Status(http.StatusOK) })
engine.GET("/api/peers", func(c *gin.Context) { c.Status(http.StatusOK) })
engine.ServeHTTP(httptest.NewRecorder(), request)
return buffer.String()
}
// Регрессия: логировался c.Request.RequestURI, то есть путь ВМЕСТЕ с query.
// Hysteria обращается к машинному endpoint'у при каждом подключении пира, так
// что токен оседал в журнале в штатном режиме работы.
func TestLogHandlerNeverLogsQueryValues(t *testing.T) {
request := httptest.NewRequest(
http.MethodPost,
"/internal/hysteria/auth?access_token="+sentinel,
strings.NewReader("{}"),
)
logged := captureLog(t, request)
if strings.Contains(logged, sentinel) {
t.Fatalf("machine token попал в журнал: %s", logged)
}
if !strings.Contains(logged, `"reqPath":"/internal/hysteria/auth"`) {
t.Fatalf("в журнале нет пути запроса: %s", logged)
}
if strings.Contains(logged, "reqUri") {
t.Fatalf("поле reqUri вернулось в журнал: %s", logged)
}
}
// Имена параметров для диагностики сохраняются: важно видеть, что параметр был
// передан, а не что в нём лежало.
func TestLogHandlerKeepsQueryKeyNames(t *testing.T) {
request := httptest.NewRequest(
http.MethodPost,
"/internal/hysteria/auth?access_token="+sentinel,
strings.NewReader("{}"),
)
logged := captureLog(t, request)
if !strings.Contains(logged, `"reqQueryKeys":"access_token"`) {
t.Fatalf("имя query-параметра не попало в журнал: %s", logged)
}
}
func TestLogHandlerOmitsQueryKeysWhenThereAreNone(t *testing.T) {
request := httptest.NewRequest(http.MethodGet, "/api/peers", nil)
logged := captureLog(t, request)
if strings.Contains(logged, "reqQueryKeys") {
t.Fatalf("пустой список параметров не должен появляться в журнале: %s", logged)
}
}
// Значение секретоподобного параметра не должно попасть в журнал ни на каком
// маршруте, а не только на машинном.
func TestLogHandlerRedactsQueryValuesOnOperatorRoutes(t *testing.T) {
request := httptest.NewRequest(http.MethodGet, "/api/peers?includeSecrets=true&name="+sentinel, nil)
logged := captureLog(t, request)
if strings.Contains(logged, sentinel) {
t.Fatalf("значение query-параметра попало в журнал: %s", logged)
}
if !strings.Contains(logged, `"reqPath":"/api/peers"`) {
t.Fatalf("в журнале нет пути запроса: %s", logged)
}
}
apps/middleware/machine_auth.go
+6 -1
View File
@@ -1,6 +1,7 @@
package middleware
import (
"crypto/subtle"
"net/http"
"strings"
@@ -38,7 +39,11 @@ func MachineAuthHandler() gin.HandlerFunc {
provided = strings.TrimSpace(c.GetHeader("X-HY2XS-Machine-Token"))
}
if provided == "" || provided != expected {
// Сравнение постоянного времени: обычное `!=` завершается на первом
// несовпавшем байте. Endpoint слушает только loopback, но локальный
// непривилегированный процесс — ровно та позиция, из которой такой
// замер и делается, а ценой ошибки здесь является machine token.
if provided == "" || subtle.ConstantTimeCompare([]byte(provided), []byte(expected)) != 1 {
c.AbortWithStatusJSON(http.StatusForbidden, gin.H{
"code": http.StatusForbidden,
"type": "no",
apps/model/constant/config.go
+82
View File
@@ -19,3 +19,85 @@ const (
Hysteria2ConfigRemark = "HYSTERIA2_CONFIG_REMARK"
ResetTrafficCron = "RESET_TRAFFIC_CRON"
)
// Что операторский API имеет право прочитать и записать в таблице `config`.
//
// Список — allowlist, и это принципиально. Раньше здесь работал denylist из
// трёх orchestrator-ключей, а `getConfig`/`listConfig` принимали произвольную
// строку. В той же таблице лежат JWT_SECRET, PEER_SECRET_KEY,
// PEER_SECRET_ENCRYPTION_KEY и HYSTERIA2_TRAFFIC_STATS_SECRET — то есть
// авторизованный запрос `?key=PEER_SECRET_ENCRYPTION_KEY` отдавал master-key
// шифрования секретов пиров, а updateConfigs позволял его подменить. После
// подмены перестают расшифровываться секреты уже существующих пиров.
//
// Именно ради этого удаляли generic export/import таблицы `config`, но точечный
// API остался прежним, и дыра просто сменила размер отверстия.
//
// Denylist здесь неверен структурно: он требует, чтобы автор КАЖДОГО нового
// ключа вспомнил про этот файл. Забытый ключ при denylist сразу публичен, при
// allowlist — сразу закрыт. Отказ по умолчанию — единственное поведение,
// которое не зависит от внимательности.
var (
// publicReadableConfigKeys — настройки, которые панель показывает оператору.
publicReadableConfigKeys = map[string]struct{}{
Hysteria2TrafficTime: {},
ResetTrafficCron: {},
Hysteria2ConfigRemark: {},
}
// publicWritableConfigKeys — подмножество читаемых, которые оператор
// действительно редактирует в интерфейсе.
//
// HYSTERIA2_CONFIG_REMARK сюда не входит: панель его только отображает.
// Право записи, которым никто не пользуется, — это attack surface без
// пользователя.
publicWritableConfigKeys = map[string]struct{}{
Hysteria2TrafficTime: {},
ResetTrafficCron: {},
}
)
// IsPublicReadableConfigKey сообщает, можно ли отдать значение ключа наружу.
func IsPublicReadableConfigKey(key string) bool {
_, ok := publicReadableConfigKeys[key]
return ok
}
// IsPublicWritableConfigKey сообщает, можно ли принять значение ключа снаружи.
func IsPublicWritableConfigKey(key string) bool {
_, ok := publicWritableConfigKeys[key]
return ok
}
// PublicReadableConfigKeys возвращает копию списка читаемых ключей.
// Используется тестами и текстами ошибок.
func PublicReadableConfigKeys() []string {
return keysOf(publicReadableConfigKeys)
}
// PublicWritableConfigKeys возвращает копию списка записываемых ключей.
func PublicWritableConfigKeys() []string {
return keysOf(publicWritableConfigKeys)
}
// InternalConfigKeys — ключи, которые не покидают процесс ни при каком
// сценарии. Объявлены явно, чтобы тест мог проверить их поимённо, а не
// полагаться на то, что их «случайно нет» в allowlist.
func InternalConfigKeys() []string {
return []string{
JwtSecret,
PeerSecretKey,
PeerSecretEncryptionKey,
Hysteria2TrafficStatsSecret,
Hysteria2Enable,
Hysteria2Config,
}
}
func keysOf(set map[string]struct{}) []string {
out := make([]string, 0, len(set))
for key := range set {
out = append(out, key)
}
return out
}
apps/model/constant/config_test.go
+66
View File
@@ -0,0 +1,66 @@
package constant
import "testing"
// Allowlist существует ровно для того, чтобы забытый ключ был закрыт, а не
// открыт. Тест закрепляет обе стороны этого утверждения поимённо.
func TestInternalKeysAreNeitherReadableNorWritable(t *testing.T) {
for _, key := range InternalConfigKeys() {
if IsPublicReadableConfigKey(key) {
t.Errorf("внутренний ключ %s доступен на чтение через API", key)
}
if IsPublicWritableConfigKey(key) {
t.Errorf("внутренний ключ %s доступен на запись через API", key)
}
}
}
func TestSecretKeysAreListedAsInternal(t *testing.T) {
required := []string{
JwtSecret,
PeerSecretKey,
PeerSecretEncryptionKey,
Hysteria2TrafficStatsSecret,
}
internal := make(map[string]struct{}, len(InternalConfigKeys()))
for _, key := range InternalConfigKeys() {
internal[key] = struct{}{}
}
for _, key := range required {
if _, ok := internal[key]; !ok {
t.Errorf("секрет %s не объявлен внутренним ключом", key)
}
}
}
func TestOperatorSettingsRemainAvailable(t *testing.T) {
for _, key := range []string{Hysteria2TrafficTime, ResetTrafficCron, Hysteria2ConfigRemark} {
if !IsPublicReadableConfigKey(key) {
t.Errorf("пользовательская настройка %s недоступна на чтение", key)
}
}
for _, key := range []string{Hysteria2TrafficTime, ResetTrafficCron} {
if !IsPublicWritableConfigKey(key) {
t.Errorf("пользовательская настройка %s недоступна на запись", key)
}
}
}
// Право записи без потребителя — это attack surface без пользователя.
// HYSTERIA2_CONFIG_REMARK панель только показывает.
func TestWritableIsSubsetOfReadable(t *testing.T) {
for _, key := range PublicWritableConfigKeys() {
if !IsPublicReadableConfigKey(key) {
t.Errorf("ключ %s можно записать, но нельзя прочитать", key)
}
}
if IsPublicWritableConfigKey(Hysteria2ConfigRemark) {
t.Error("HYSTERIA2_CONFIG_REMARK не редактируется в панели и не должен быть записываемым")
}
}
func TestUnknownKeyIsClosedByDefault(t *testing.T) {
if IsPublicReadableConfigKey("SOME_FUTURE_KEY") || IsPublicWritableConfigKey("SOME_FUTURE_KEY") {
t.Fatal("неизвестный ключ обязан быть закрыт по умолчанию")
}
}
apps/model/dto/config.go
+3 -3
View File
@@ -1,8 +1,8 @@
package dto
type ConfigDto struct {
Key *string `json:"key" form:"key" validate:"required,min=1,max=128"`
}
// ConfigDto удалён вместе с маршрутом GET /config/getConfig: чтение
// произвольного ключа таблицы `config` было точечным входом к JWT- и
// peer-ключам. Чтение идёт через ConfigsDto и allowlist.
type ConfigsDto struct {
Keys []string `json:"keys" form:"keys" validate:"required"`
apps/model/entity/account.go
-25
View File
@@ -1,25 +0,0 @@
package entity
type LegacyAccount struct {
Username *string `gorm:"column:username;default:''" json:"username"`
Pass *string `gorm:"column:pass;default:''" json:"pass"`
ConPass *string `gorm:"column:con_pass;default:''" json:"conPass"`
Quota *int64 `gorm:"column:quota;default:0" json:"quota"`
Download *int64 `gorm:"column:download;default:0" json:"download"`
Upload *int64 `gorm:"column:upload;default:0" json:"upload"`
ExpireTime *int64 `gorm:"column:expire_time;default:0" json:"expireTime"`
KickUtilTime *int64 `gorm:"column:kick_util_time;default:0" json:"kickUtilTime"`
DeviceNo *int64 `gorm:"column:device_no;default:3" json:"deviceNo"`
Role *string `gorm:"column:role;default:'user'" json:"role"`
Deleted *int64 `gorm:"column:deleted;default:0" json:"deleted"`
BaseEntity `gorm:"embedded"`
LoginAt *int64 `gorm:"column:login_at;default:0" json:"loginAt"`
ConAt *int64 `gorm:"column:con_at;default:0" json:"conAt"`
Remark *string `gorm:"column:remark;default:''" json:"remark"`
ForcePasswordChange *int64 `gorm:"column:force_password_change;default:0" json:"forcePasswordChange"`
}
func (LegacyAccount) TableName() string {
return "account"
}
apps/model/vo/log.go
+15 -8
View File
@@ -5,15 +5,22 @@ type LogSystemPage[T LogSystemVo | LogHysteria2Vo] struct {
Total int64 `json:"total"`
}
// LogSystemVo — строка журнала админки в том виде, в каком её пишет
// middleware.LogHandler.
//
// Поля reqUri здесь нет намеренно: RequestURI несёт query string, а по
// машинному endpoint'у в ней приезжает действующий machine token. Логируется
// путь и, отдельно, имена переданных query-параметров без значений.
type LogSystemVo struct {
ClientIP string `json:"clientIp"`
LatencyTime int64 `json:"latencyTime"`
Level string `json:"level"`
Msg string `json:"msg"`
ReqMethod string `json:"reqMethod"`
ReqUri string `json:"reqUri"`
StatusCode int64 `json:"statusCode"`
Time string `json:"time"`
ClientIP string `json:"clientIp"`
LatencyTime int64 `json:"latencyTime"`
Level string `json:"level"`
Msg string `json:"msg"`
ReqMethod string `json:"reqMethod"`
ReqPath string `json:"reqPath"`
ReqQueryKeys string `json:"reqQueryKeys"`
StatusCode int64 `json:"statusCode"`
Time string `json:"time"`
}
type LogHysteria2Vo struct {
apps/router/config.go
+6 -1
View File
@@ -14,11 +14,16 @@ import (
// По той же причине здесь нет generic exportConfig/importConfig: они отдавали
// и принимали таблицу `config` целиком, вместе с JWT- и peer-ключами.
// См. комментарий в controller/config.go.
//
// Маршрута getConfig тоже нет. Он принимал произвольный ключ и был вторым
// входом в ту же таблицу секретов, только точечным: `?key=JWT_SECRET`
// возвращал подписывающий ключ, `?key=PEER_SECRET_ENCRYPTION_KEY` — master-key
// шифрования секретов пиров. Потребителей у маршрута не было ни одного:
// панель читает настройки через listConfig, у которого теперь allowlist.
func initConfigRouter(configApi *gin.RouterGroup) {
config := configApi.Group("/config")
{
config.POST("/updateConfigs", controller.UpdateConfigs)
config.GET("/getConfig", controller.GetConfig)
config.POST("/listConfig", controller.ListConfig)
config.GET("/getHysteria2Config", controller.GetHysteria2Config)
config.POST("/exportHysteria2Config", controller.ExportHysteria2Config)
apps/router/router_test.go
+35
View File
@@ -84,6 +84,10 @@ func TestRouterHasNoRemovedRoutes(t *testing.T) {
"restartServer",
"uploadCertFile",
"hysteria2AcmePath",
// getConfig принимал произвольный ключ таблицы `config` и был точечным
// входом к JWT_SECRET, PEER_SECRET_KEY и PEER_SECRET_ENCRYPTION_KEY.
// Потребителей у него не было ни одного.
"getConfig",
}
for _, route := range buildRoutes(t) {
for _, dead := range removed {
@@ -94,6 +98,37 @@ func TestRouterHasNoRemovedRoutes(t *testing.T) {
}
}
// Оставшиеся маршруты /config — это чтение по allowlist, запись по allowlist и
// санитизирующая выгрузка серверного конфига. Никакого generic-доступа к
// таблице `config` у API быть не должно.
func TestRouterConfigNamespaceIsClosed(t *testing.T) {
allowed := map[string]bool{
constant.AdminAPIBase + "/config/updateConfigs": true,
constant.AdminAPIBase + "/config/listConfig": true,
constant.AdminAPIBase + "/config/getHysteria2Config": true,
constant.AdminAPIBase + "/config/exportHysteria2Config": true,
}
for _, route := range buildRoutes(t) {
if !strings.HasPrefix(route.Path, constant.AdminAPIBase+"/config") {
continue
}
if !allowed[route.Path] {
t.Errorf("в пространстве /config появился неожиданный маршрут: %s %s", route.Method, route.Path)
}
}
present := make(map[string]bool)
for _, route := range buildRoutes(t) {
present[route.Path] = true
}
for path := range allowed {
if !present[path] {
t.Errorf("маршрут %s пропал", path)
}
}
}
func TestRouterExposesHealthz(t *testing.T) {
found := false
for _, route := range buildRoutes(t) {
apps/service/journal.go
+12 -2
View File
@@ -58,10 +58,19 @@ func ReadHysteriaJournalLogs(numLine int) ([]vo.LogHysteria2Vo, int, error) {
return result, len(result), nil
}
// ExportHysteriaJournalLogs отдаёт журнал Hysteria оператору.
//
// Файл покидает сервер, поэтому проходит тот же санитайз, что и остальные
// выгружаемые артефакты: HY2_AUTH_URL несёт access_token, и upstream волен
// упомянуть его в сообщении об ошибке обращения к auth-backend.
func ExportHysteriaJournalLogs(numLine int) (string, error) {
lines := normalizeJournalLineLimit(numLine, 5000, 10000)
return util.Exec(fmt.Sprintf("journalctl --no-pager -u hysteria-server.service -n %d -o short-iso", lines))
output, err := util.Exec(fmt.Sprintf("journalctl --no-pager -u hysteria-server.service -n %d -o short-iso", lines))
if err != nil {
return "", err
}
return SanitizeLogText(output), nil
}
func parseHysteriaJournalRecord(item journalctlLogLine) vo.LogHysteria2Vo {
@@ -87,12 +96,13 @@ func parseHysteriaJournalRecord(item journalctlLogLine) vo.LogHysteria2Vo {
if parsed.Msg == "" {
parsed.Msg = item.Message
}
parsed.Msg = SanitizeLogText(parsed.Msg)
return parsed
}
return vo.LogHysteria2Vo{
Level: fallbackLevel,
Msg: item.Message,
Msg: SanitizeLogText(item.Message),
Time: fallbackTime,
}
}
apps/service/log_sanitize.go
+78
View File
@@ -0,0 +1,78 @@
package service
import (
"regexp"
"strings"
)
// Санитайз свободного текста логов.
//
// Отличается от YAML-санитайзера тем, что у него нет структуры: журнал — это
// строки, а не документ. Поэтому правил ровно два и оба консервативные:
//
// 1. всё, что разбирается как URL, прогоняется через тот же sanitizeURLValue,
// что и экспорт конфига: host/port/path остаются читаемыми, встроенные
// учётные данные и секретные query-параметры вырезаются;
// 2. отдельно ловятся пары `имя=значение` с секретоподобным именем, которые
// встречаются в тексте вне URL.
//
// Зачем это журналу Hysteria: HY2_AUTH_URL содержит access_token, и upstream
// волен упомянуть его в сообщении об ошибке обращения к auth-backend. Свой
// журнал админки мы контролируем, чужой — нет, а ExportLog отдаёт его
// оператору тем же файлом.
var logURLPattern = regexp.MustCompile(`[a-zA-Z][a-zA-Z0-9+.\-]*://[^\s"'<>` + "`" + `]+`)
// Имена подобраны по тем же маркерам, что и secretKeyMarkers, но записаны
// явным перечислением: в свободном тексте подстрочный поиск по «token» дал бы
// слишком много ложных срабатываний на словах вроде «tokenizer».
var logSecretAssignmentPattern = regexp.MustCompile(
`(?i)([a-z0-9_\-]*(?:access_token|token|secret|password|passwd|passphrase|credential|api_?key|authorization|signature)[a-z0-9_\-]*)\s*[=:]\s*([^\s&,;"'<>` + "`" + `]+)`,
)
// SanitizeLogText вырезает секреты из произвольного текста журнала.
func SanitizeLogText(raw string) string {
if raw == "" {
return raw
}
withSafeURLs := logURLPattern.ReplaceAllStringFunc(raw, func(match string) string {
body, trailing := splitTrailingPunctuation(match)
return sanitizeURLValue(body) + trailing
})
return logSecretAssignmentPattern.ReplaceAllStringFunc(withSafeURLs, func(match string) string {
groups := logSecretAssignmentPattern.FindStringSubmatch(match)
if len(groups) != 3 {
return match
}
value, trailing := splitTrailingPunctuation(groups[2])
// Значение уже вырезано URL-санитайзером: percent-кодированный маркер
// внутри готового URL трогать нельзя, иначе адрес перестанет быть
// валидным URL.
if value == RedactedPlaceholder || strings.EqualFold(value, encodedRedactedPlaceholder) {
return match
}
separator := "="
if strings.Contains(match, ":") && !strings.Contains(match, "=") {
separator = ": "
}
return groups[1] + separator + RedactedPlaceholder + trailing
})
}
// encodedRedactedPlaceholder — то, во что превращается маркер внутри query
// после url.Values.Encode().
const encodedRedactedPlaceholder = "%3Credacted%3E"
// splitTrailingPunctuation отделяет хвостовую пунктуацию предложения от
// значения: в «...access_token=abc.» точка принадлежит тексту, а не токену.
func splitTrailingPunctuation(value string) (string, string) {
end := len(value)
for end > 0 && strings.ContainsRune(".,;:)]}!?", rune(value[end-1])) {
end--
}
return value[:end], value[end:]
}
apps/service/log_sanitize_test.go
+80
View File
@@ -0,0 +1,80 @@
package service
import (
"strings"
"testing"
)
const journalSentinel = "SUPER_SECRET_SENTINEL"
func TestSanitizeLogTextRemovesMachineTokenFromUrl(t *testing.T) {
raw := `Aug 27 12:00:01 host hysteria[123]: {"level":"error","msg":"auth backend error: ` +
`Post \"http://127.0.0.1:8080/internal/hysteria/auth?access_token=` + journalSentinel + `\": EOF"}`
sanitized := SanitizeLogText(raw)
if strings.Contains(sanitized, journalSentinel) {
t.Fatalf("machine token остался в журнале: %s", sanitized)
}
// Адрес обязан остаться читаемым: диагностика теряет смысл, если из строки
// пропадает host и path.
if !strings.Contains(sanitized, "127.0.0.1:8080/internal/hysteria/auth") {
t.Fatalf("санитайз съел адрес целиком: %s", sanitized)
}
}
func TestSanitizeLogTextRemovesBareAssignments(t *testing.T) {
cases := []string{
"connecting with access_token=" + journalSentinel,
"trafficStats secret=" + journalSentinel + " rejected",
"obfs password: " + journalSentinel,
"Authorization=" + journalSentinel,
}
for _, raw := range cases {
sanitized := SanitizeLogText(raw)
if strings.Contains(sanitized, journalSentinel) {
t.Errorf("секрет остался в строке %q: %s", raw, sanitized)
}
}
}
func TestSanitizeLogTextKeepsOrdinaryLines(t *testing.T) {
raw := "server up and running, listening on 0.0.0.0:443"
if sanitized := SanitizeLogText(raw); sanitized != raw {
t.Fatalf("обычная строка изменена: %q -> %q", raw, sanitized)
}
}
// Хвостовая пунктуация не является частью адреса.
func TestSanitizeLogTextKeepsTrailingPunctuation(t *testing.T) {
raw := "failed to call http://127.0.0.1:8080/internal/hysteria/auth?access_token=" + journalSentinel + "."
sanitized := SanitizeLogText(raw)
if strings.Contains(sanitized, journalSentinel) {
t.Fatalf("machine token остался: %s", sanitized)
}
if !strings.HasSuffix(sanitized, ".") {
t.Fatalf("потеряна хвостовая пунктуация: %s", sanitized)
}
}
// Двойной проход не должен ломать уже вырезанное значение.
func TestSanitizeLogTextIsIdempotent(t *testing.T) {
raw := "http://127.0.0.1:8080/internal/hysteria/auth?access_token=" + journalSentinel
once := SanitizeLogText(raw)
twice := SanitizeLogText(once)
if once != twice {
t.Fatalf("санитайз не идемпотентен: %q -> %q", once, twice)
}
}
func TestSanitizeLogTextEmptyInput(t *testing.T) {
if SanitizeLogText("") != "" {
t.Fatal("пустой вход должен оставаться пустым")
}
}
apps/service/peer.go
+192 -95
View File
@@ -204,119 +204,216 @@ func ListExportPeer(includeSecrets bool) ([]bo.PeerExport, error) {
return out, nil
}
func UpsertPeerExport(items []bo.PeerExport) error {
// Первый проход — только проверка. Импорт либо применяется целиком, либо
// не применяется вовсе: наполовину импортированный список пиров хуже
// отклонённого файла.
if err := ValidatePeerImportBatch(items); err != nil {
return err
}
// preparedPeerImport — запись импорта со всем криптоматериалом, посчитанным
// заранее.
//
// Крипто выносится ИЗ транзакции сознательно. PeerSecretDigest и
// EncryptPeerSecret читают ключи из таблицы `config`, то есть ходят в ту же
// базу; делать это, удерживая открытую запись, значит без нужды держать
// блокировку на время AES по каждой из тысяч записей. Внутри транзакции должна
// остаться только работа с таблицей пиров.
type preparedPeerImport struct {
source bo.PeerExport
name string
authID string
remark string
quota int64
expires int64
maxDevices int64
disabled int64
// Задан, только если секрет пришёл в файле: у существующего пира секрет
// перезаписывается лишь в этом случае.
hasExplicitSecret bool
explicitDigest string
explicitCipher string
// Готовятся всегда: понадобятся, если запись окажется новой.
createDigest string
createCipher string
createAuthID string
}
func preparePeerImport(items []bo.PeerExport) ([]preparedPeerImport, error) {
prepared := make([]preparedPeerImport, 0, len(items))
for _, item := range items {
name := strings.TrimSpace(item.Name)
var existing entity.Peer
var err error
authID := strings.TrimSpace(item.AuthId)
if authID != "" {
existing, err = dao.GetPeer("auth_id = ?", authID)
}
if err != nil || existing.Id == nil {
existing, err = dao.GetPeer("name = ?", name)
}
// Пир установщика не переопределяется импортом ни при каком совпадении:
// его секрет живёт ещё и в /etc/hy2xs/bootstrap-admin.secret.
if err == nil && existing.Name != nil && *existing.Name == ReservedBootstrapPeerName {
return fmt.Errorf("peer import: пир %q принадлежит установщику и не может быть изменён импортом", ReservedBootstrapPeerName)
}
quota := item.QuotaBytes
expires := item.ExpiresAt
maxDevices := item.MaxDevices
if maxDevices <= 0 {
maxDevices = 3
}
disabled := item.Disabled
remark := item.Remark
if err == nil && existing.Id != nil {
updates := map[string]interface{}{
"name": name,
"remark": remark,
"quota_bytes": quota,
"download_bytes": item.DownloadBytes,
"upload_bytes": item.UploadBytes,
"expires_at": expires,
"max_devices": maxDevices,
"disabled": disabled,
"banned_until": item.BannedUntil,
"last_connection_at": item.LastConnectionAt,
}
if authID != "" {
updates["auth_id"] = authID
}
if strings.TrimSpace(item.Secret) != "" {
digest, derr := PeerSecretDigest(item.Secret)
if derr != nil {
return derr
}
enc, eerr := EncryptPeerSecret(item.Secret)
if eerr != nil {
return eerr
}
updates["secret_digest"] = digest
updates["secret_ciphertext"] = enc
}
if uerr := dao.UpdatePeer([]int64{*existing.Id}, updates); uerr != nil {
return uerr
}
continue
entry := preparedPeerImport{
source: item,
name: name,
authID: authID,
remark: item.Remark,
quota: item.QuotaBytes,
expires: item.ExpiresAt,
maxDevices: maxDevices,
disabled: item.Disabled,
}
createSecret := strings.TrimSpace(item.Secret)
if createSecret == "" {
generated, gerr := util.RandomString(24)
if gerr != nil {
return gerr
}
createSecret = fmt.Sprintf("%s.%s", name, generated)
}
secretDigest, derr := PeerSecretDigest(createSecret)
if derr != nil {
return derr
}
secretEncrypted, eerr := EncryptPeerSecret(createSecret)
if eerr != nil {
return eerr
}
if authID == "" {
authID, err = util.RandomString(18)
explicitSecret := strings.TrimSpace(item.Secret)
if explicitSecret != "" {
digest, err := PeerSecretDigest(explicitSecret)
if err != nil {
return nil, err
}
cipher, err := EncryptPeerSecret(explicitSecret)
if err != nil {
return nil, err
}
entry.hasExplicitSecret = true
entry.explicitDigest = digest
entry.explicitCipher = cipher
entry.createDigest = digest
entry.createCipher = cipher
} else {
generated, err := util.RandomString(24)
if err != nil {
return nil, err
}
createSecret := fmt.Sprintf("%s.%s", name, generated)
digest, err := PeerSecretDigest(createSecret)
if err != nil {
return nil, err
}
cipher, err := EncryptPeerSecret(createSecret)
if err != nil {
return nil, err
}
entry.createDigest = digest
entry.createCipher = cipher
}
entry.createAuthID = authID
if entry.createAuthID == "" {
generated, err := util.RandomString(18)
if err != nil {
return nil, err
}
entry.createAuthID = generated
}
prepared = append(prepared, entry)
}
return prepared, nil
}
// UpsertPeerExport применяет выгрузку пиров целиком или не применяет вовсе.
//
// Три прохода, и каждый отвечает за своё:
//
// 1. ValidatePeerImportBatch — содержимое файла, без обращения к базе;
// 2. preparePeerImport — весь криптоматериал, без обращения к таблице пиров;
// 3. одна транзакция — только записи.
//
// Раньше третьего прохода не существовало: записи шли по одной, каждая своим
// оператором. Комментарий обещал «либо целиком, либо никак», но UNIQUE-конфликт
// на 37-й записи оставлял 36 применённых, и откатить это оператор уже не мог.
// Конфликт не гипотетический: пусть в базе есть A(auth_id=a, name=alice) и
// B(auth_id=b, name=bob), а файл несёт (auth_id=a, name=bob). Поиск найдёт A
// по auth_id и переименует его в bob — прямо в UNIQUE(name).
func UpsertPeerExport(items []bo.PeerExport) error {
if err := ValidatePeerImportBatch(items); err != nil {
return err
}
prepared, err := preparePeerImport(items)
if err != nil {
return err
}
return dao.WithPeerTx(func(tx dao.PeerTx) error {
for _, entry := range prepared {
if err := applyPeerImportEntry(tx, entry); err != nil {
return err
}
}
return nil
})
}
peer := entity.Peer{
Name: &name,
Remark: &remark,
AuthId: &authID,
SecretDigest: &secretDigest,
SecretEncrypted: &secretEncrypted,
QuotaBytes: &quota,
DownloadBytes: &item.DownloadBytes,
UploadBytes: &item.UploadBytes,
ExpiresAt: &expires,
MaxDevices: &maxDevices,
Disabled: &disabled,
BannedUntil: &item.BannedUntil,
LastConnectionAt: &item.LastConnectionAt,
}
if _, serr := dao.SavePeer(peer); serr != nil {
return serr
}
func applyPeerImportEntry(tx dao.PeerTx, entry preparedPeerImport) error {
var existing entity.Peer
var err error
if entry.authID != "" {
existing, err = tx.GetPeer("auth_id = ?", entry.authID)
}
return nil
if err != nil || existing.Id == nil {
existing, err = tx.GetPeer("name = ?", entry.name)
}
// Пир установщика не переопределяется импортом ни при каком совпадении:
// его секрет живёт ещё и в /etc/hy2xs/bootstrap-admin.secret.
if err == nil && existing.Name != nil && *existing.Name == ReservedBootstrapPeerName {
return fmt.Errorf(
"peer import: пир %q принадлежит установщику и не может быть изменён импортом",
ReservedBootstrapPeerName,
)
}
if err == nil && existing.Id != nil {
updates := map[string]interface{}{
"name": entry.name,
"remark": entry.remark,
"quota_bytes": entry.quota,
"download_bytes": entry.source.DownloadBytes,
"upload_bytes": entry.source.UploadBytes,
"expires_at": entry.expires,
"max_devices": entry.maxDevices,
"disabled": entry.disabled,
"banned_until": entry.source.BannedUntil,
"last_connection_at": entry.source.LastConnectionAt,
}
if entry.authID != "" {
updates["auth_id"] = entry.authID
}
if entry.hasExplicitSecret {
updates["secret_digest"] = entry.explicitDigest
updates["secret_ciphertext"] = entry.explicitCipher
}
return tx.UpdatePeer([]int64{*existing.Id}, updates)
}
name := entry.name
remark := entry.remark
authID := entry.createAuthID
digest := entry.createDigest
cipher := entry.createCipher
quota := entry.quota
expires := entry.expires
maxDevices := entry.maxDevices
disabled := entry.disabled
download := entry.source.DownloadBytes
upload := entry.source.UploadBytes
bannedUntil := entry.source.BannedUntil
lastConnection := entry.source.LastConnectionAt
peer := entity.Peer{
Name: &name,
Remark: &remark,
AuthId: &authID,
SecretDigest: &digest,
SecretEncrypted: &cipher,
QuotaBytes: &quota,
DownloadBytes: &download,
UploadBytes: &upload,
ExpiresAt: &expires,
MaxDevices: &maxDevices,
Disabled: &disabled,
BannedUntil: &bannedUntil,
LastConnectionAt: &lastConnection,
}
_, saveErr := tx.SavePeer(peer)
return saveErr
}
func ExistPeerName(name string, id int64) bool {
apps/service/peer_import_tx_test.go
+267
View File
@@ -0,0 +1,267 @@
package service
import (
"path/filepath"
"strings"
"testing"
"hy2xs-admin/dao"
"hy2xs-admin/model/bo"
"hy2xs-admin/model/entity"
)
// Тесты транзакционности импорта работают на настоящей SQLite: UNIQUE-конфликт,
// ради которого транзакция и нужна, воспроизводится только в базе. Схема
// поднимается отдельно от InitSql — bootstrap-администратор и bootstrap-пир
// здесь не нужны и только мешали бы читать ожидания.
func newTestDB(t *testing.T) {
t.Helper()
dbPath := filepath.Join(t.TempDir(), "hy2xs-admin-test.db")
if err := dao.InitSqliteDBAt(dbPath); err != nil {
t.Fatalf("не удалось открыть тестовую базу: %v", err)
}
if err := dao.RunMigrations(); err != nil {
t.Fatalf("не удалось применить миграции: %v", err)
}
t.Cleanup(func() {
_ = dao.CloseSqliteDB()
})
}
func seedPeer(t *testing.T, name string, authID string) int64 {
t.Helper()
digest, err := PeerSecretDigest(name + "-secret")
if err != nil {
t.Fatalf("digest: %v", err)
}
cipher, err := EncryptPeerSecret(name + "-secret")
if err != nil {
t.Fatalf("encrypt: %v", err)
}
remark := ""
quota := int64(-1)
zero := int64(0)
maxDevices := int64(3)
id, err := dao.SavePeer(entity.Peer{
Name: &name,
Remark: &remark,
AuthId: &authID,
SecretDigest: &digest,
SecretEncrypted: &cipher,
QuotaBytes: &quota,
DownloadBytes: &zero,
UploadBytes: &zero,
ExpiresAt: &zero,
MaxDevices: &maxDevices,
Disabled: &zero,
BannedUntil: &zero,
LastConnectionAt: &zero,
})
if err != nil {
t.Fatalf("не удалось создать пира %s: %v", name, err)
}
return id
}
func snapshotPeers(t *testing.T) map[string]entity.Peer {
t.Helper()
peers, err := dao.ListPeer("1=1")
if err != nil {
t.Fatalf("не удалось прочитать пиров: %v", err)
}
out := make(map[string]entity.Peer, len(peers))
for _, peer := range peers {
out[*peer.Name] = peer
}
return out
}
func importItem(name string, authID string) bo.PeerExport {
return bo.PeerExport{
Name: name,
AuthId: authID,
QuotaBytes: -1,
MaxDevices: 3,
}
}
func TestUpsertPeerExportAppliesWholeBatch(t *testing.T) {
newTestDB(t)
items := []bo.PeerExport{
importItem("alpha1", ""),
importItem("bravo2", ""),
importItem("charl3", ""),
}
if err := UpsertPeerExport(items); err != nil {
t.Fatalf("валидный импорт отклонён: %v", err)
}
peers := snapshotPeers(t)
if len(peers) != 3 {
t.Fatalf("ожидалось 3 пира, получено %d", len(peers))
}
for _, name := range []string{"alpha1", "bravo2", "charl3"} {
if _, ok := peers[name]; !ok {
t.Errorf("пир %s не создан", name)
}
}
}
// Главная регрессия: cross-conflict, описанный в комментарии к UpsertPeerExport.
//
// В базе A(auth_id=aaa, name=alice1) и B(auth_id=bbb, name=bob123).
// Импорт несёт запись (auth_id=aaa, name=bob123): поиск найдёт A по auth_id и
// попытается переименовать её в bob123 — прямо в UNIQUE(name).
//
// До транзакции всё, что шло в файле ДО конфликтной записи, оставалось
// применённым.
func TestUpsertPeerExportRollsBackCrossConflict(t *testing.T) {
newTestDB(t)
seedPeer(t, "alice1", "aaa")
seedPeer(t, "bob123", "bbb")
before := snapshotPeers(t)
items := []bo.PeerExport{
importItem("first1", ""), // применилась бы
importItem("second", ""), // применилась бы
importItem("bob123", "aaa"), // UNIQUE(name) конфликт
importItem("fourth", ""), // до неё дело не дойдёт
}
err := UpsertPeerExport(items)
if err == nil {
t.Fatal("импорт с конфликтом UNIQUE должен быть отклонён")
}
// Отказ обязан прийти из базы, а не из валидации: иначе тест доказывал бы
// только то, что файл не прошёл проверку, и про откат не говорил бы ничего.
if strings.HasPrefix(err.Error(), "peer import:") {
t.Fatalf("ожидался отказ базы, получен отказ валидации: %v", err)
}
after := snapshotPeers(t)
if len(after) != len(before) {
t.Fatalf("состояние базы изменилось: было %d пиров, стало %d", len(before), len(after))
}
for name, peer := range before {
got, ok := after[name]
if !ok {
t.Errorf("пир %s пропал после отката", name)
continue
}
if *got.AuthId != *peer.AuthId {
t.Errorf("у пира %s изменился auth_id: %s -> %s", name, *peer.AuthId, *got.AuthId)
}
}
for _, name := range []string{"first1", "second", "fourth"} {
if _, ok := after[name]; ok {
t.Errorf("частично применённый импорт: пир %s остался в базе", name)
}
}
}
// Тот же инвариант на дубликате auth_id: конфликт возникает на вставке, а не
// на обновлении.
func TestUpsertPeerExportRollsBackDuplicateAuthId(t *testing.T) {
newTestDB(t)
seedPeer(t, "exist1", "shared-auth-id")
before := snapshotPeers(t)
items := []bo.PeerExport{
importItem("newone", ""),
// Имя новое, поэтому запись будет вставляться, а auth_id уже занят.
importItem("newtwo", "shared-auth-id"),
}
err := UpsertPeerExport(items)
if err == nil {
// Совпадение по auth_id приводит к обновлению существующего пира —
// это допустимая семантика upsert. Тогда проверяем, что первая запись
// применилась вместе со второй, а не вместо неё.
after := snapshotPeers(t)
if _, ok := after["newone"]; !ok {
t.Fatal("успешный импорт не применил первую запись")
}
return
}
after := snapshotPeers(t)
if len(after) != len(before) {
t.Fatalf("частичный импорт: было %d пиров, стало %d", len(before), len(after))
}
if _, ok := after["newone"]; ok {
t.Error("частично применённый импорт: пир newone остался в базе")
}
}
// Отказ подготовки (валидация партии) не должен доходить до базы вовсе.
func TestUpsertPeerExportRejectsInvalidBatchBeforeAnyWrite(t *testing.T) {
newTestDB(t)
items := []bo.PeerExport{
importItem("valid1", ""),
importItem("bad", ""), // короче 6 символов
}
if err := UpsertPeerExport(items); err == nil {
t.Fatal("партия с невалидной записью должна быть отклонена")
}
if peers := snapshotPeers(t); len(peers) != 0 {
t.Fatalf("отклонённая партия оставила записи в базе: %d", len(peers))
}
}
// Пир установщика защищён и внутри транзакции: отказ обязан откатить всё, что
// успело примениться до него.
func TestUpsertPeerExportRollsBackOnBootstrapPeer(t *testing.T) {
newTestDB(t)
seedPeer(t, ReservedBootstrapPeerName, ReservedBootstrapPeerName)
items := []bo.PeerExport{
importItem("first1", ""),
// Имя зарезервировано, поэтому валидация не пропустит его напрямую;
// совпадение достигается через auth_id установщика.
importItem("second", ReservedBootstrapPeerName),
}
if err := UpsertPeerExport(items); err == nil {
t.Fatal("импорт, задевающий пира установщика, должен быть отклонён")
}
after := snapshotPeers(t)
if _, ok := after["first1"]; ok {
t.Error("частично применённый импорт: пир first1 остался в базе")
}
}
// Обновление существующего пира без секрета в файле не должно трогать его
// секрет: иначе перенос настроек ломал бы работающие клиентские ссылки.
func TestUpsertPeerExportKeepsSecretWhenFileHasNone(t *testing.T) {
newTestDB(t)
seedPeer(t, "keeper", "keeper-auth")
before := snapshotPeers(t)["keeper"]
item := importItem("keeper", "keeper-auth")
item.Remark = "updated remark"
if err := UpsertPeerExport([]bo.PeerExport{item}); err != nil {
t.Fatalf("импорт отклонён: %v", err)
}
after := snapshotPeers(t)["keeper"]
if *after.SecretDigest != *before.SecretDigest {
t.Error("секрет пира перезаписан, хотя в файле его не было")
}
if *after.Remark != "updated remark" {
t.Errorf("remark не обновился: %q", *after.Remark)
}
}