fix(v1): разблокировать сборку, починить жизненный цикл cron и закрыть каналы утечки
Сборка не собиралась: два контракта приёмки роняли её на корректном коде.
verify_api_namespace_contract искал возвращение legacy-пространства имён
через grep по '/hui' и находил router_test.go, который ПЕРЕЧИСЛЯЕТ этот
префикс, чтобы доказать отсутствие маршрута, и сам versions.sh, где строка
стоит в тексте проверки. Падение приходило шестым шагом из четырнадцати, до
резолва Hysteria. За ним прятался второй такой же: проверка транзакционности
импорта пиров брала файл от начала applyPeerImportEntry и до конца, захватывая
объявленные ниже ExistPeerName и UpdatePeerLastConnectionAt.
Обе проверки теперь смотрят на код, а не на упоминания: добавлены помощники
code_without_comments и code_mentions_in, а отсутствие legacy-маршрута
доказывает тест на таблице маршрутов собранного роутера.
Планировщик стал собственностью процесса. InitCron вызывался из runServer и
на каждом вызове создавал новый cron.New(), не сохраняя ссылку; cron.Stop()
не вызывался нигде. Смена RESET_TRAFFIC_CRON выполняла StopServer(), точка
входа крутила for { runServer() } — и каждая правка добавляла целый
дублирующий набор джоб, а старое расписание сброса продолжало работать.
Фиксированные джобы регистрируются один раз, расписание переносится на месте
по EntryID, HTTP-сервер не трогается. Добавлено штатное завершение по SIGTERM.
Выражение проверяется до записи в базу тем же парсером (cron.ParseStandard),
которым его разбирает планировщик: раньше невалидная строка сохранялась, API
отвечал успехом, а сброс трафика молча исчезал.
updateConfigs стал атомарным: полная проверка партии, одна транзакция,
применение к рантайму. Прежний тест ставил запрещённый ключ первым и не
смотрел в базу — поймать частичное применение он был неспособен.
Удалены четыре ключа таблицы config без единого потребителя: HYSTERIA2_ENABLE,
HYSTERIA2_CONFIG (второй источник истины, читался первым), HYSTERIA2_TRAFFIC_TIME
и HYSTERIA2_CONFIG_REMARK. Имя профиля в share URI выводится из имени пира.
Безопасность:
- bootstrap-пароль администратора больше не генерируется и не пишется в журнал,
который отдаётся кнопкой выгрузки; отсутствие env — отказ старта;
- собственный журнал админки санитизируется наравне с чужим;
- golang-jwt/jwt v3 -> v5: GO-2025-3553 не имеет исправленной версии в v3 и
достижима с неаутентифицированного запроса; набор алгоритмов подписи
зафиксирован через WithValidMethods;
- удалён вход по несолёному SHA-224 из предыдущего поколения;
- убран modulo bias в util.RandomString — единственном генераторе секретов;
- пир установщика защищён во всех путях записи, а не только в импорте;
- удалена латентная паника в service.GetToken и недостижимая ветка GetAdminInfo,
проверявшая меньше, чем middleware.
Toolchain: Go 1.21.13 -> 1.26.7, Node 20.19.0 (EOL) -> 24.20.0. На прежнем
графе govulncheck находил 21 вызываемую уязвимость, 17 из них в stdlib,
попадающей в production-бинарь. Сейчас — ноль. Добавлен обязательный шаг
проверки зависимостей (govulncheck + pnpm audit) с записью результата в
metadata пакета.
This commit is contained in:
+20
-16
@@ -30,16 +30,9 @@ func Login(username string, plainPassword string) (string, bool, error) {
|
||||
if err != nil {
|
||||
return "", false, err
|
||||
}
|
||||
verified, legacy := util.VerifyPassword(plainPassword, *admin.PasswordHash)
|
||||
if !verified {
|
||||
if !util.VerifyPassword(plainPassword, *admin.PasswordHash) {
|
||||
return "", false, errors.New(constant.WrongPassword)
|
||||
}
|
||||
if legacy {
|
||||
hash, hashErr := util.HashPassword(plainPassword)
|
||||
if hashErr == nil {
|
||||
_ = dao.UpdateAdminUser([]int64{*admin.Id}, map[string]interface{}{"password_hash": hash})
|
||||
}
|
||||
}
|
||||
tokenVersion := int64(1)
|
||||
if admin.TokenVersion != nil && *admin.TokenVersion > 0 {
|
||||
tokenVersion = *admin.TokenVersion
|
||||
@@ -49,21 +42,33 @@ func Login(username string, plainPassword string) (string, bool, error) {
|
||||
if tokenErr != nil {
|
||||
return "", false, tokenErr
|
||||
}
|
||||
requirePasswordChange := legacy
|
||||
// Признак «пароль в старом формате, заставить сменить» отсюда убран вместе
|
||||
// с поддержкой самого формата: единственный источник этого требования —
|
||||
// флаг force_password_change, который ставит установка.
|
||||
requirePasswordChange := false
|
||||
if admin.ForcePasswordChange != nil {
|
||||
requirePasswordChange = *admin.ForcePasswordChange != 0
|
||||
}
|
||||
return token, requirePasswordChange, nil
|
||||
}
|
||||
|
||||
// GetAdminInfo читает учётные данные ТОЛЬКО из контекста запроса.
|
||||
//
|
||||
// Резервной ветки «если в контексте пусто — разобрать токен самостоятельно»
|
||||
// здесь больше нет. Она была недостижима: все маршруты, ведущие сюда, стоят за
|
||||
// middleware.JWTHandler, который разбирает токен, сверяет token_version и
|
||||
// кладёт claims в контекст. При этом ветка несла собственный разбор заголовка
|
||||
// Authorization через service.GetToken, где strings.SplitN(...)[1] паниковал
|
||||
// на заголовке без пробела.
|
||||
//
|
||||
// Хуже недостижимости было бы её оживление: этот путь не проверял ни статус
|
||||
// учётной записи, ни версию токена, то есть отозванный токен прошёл бы здесь,
|
||||
// но не прошёл бы через middleware. Второй способ аутентификации, слабее
|
||||
// первого, — не запасной вариант, а обход.
|
||||
func GetAdminInfo(c *gin.Context) (vo.AdminInfoVo, error) {
|
||||
claims, ok := adminClaimsFromContext(c)
|
||||
if !ok {
|
||||
myClaims, err := ParseToken(GetToken(c))
|
||||
if err != nil {
|
||||
return vo.AdminInfoVo{}, err
|
||||
}
|
||||
claims = myClaims.Admin
|
||||
return vo.AdminInfoVo{}, errors.New(constant.UnauthorizedError)
|
||||
}
|
||||
admin, err := dao.GetAdminUser("id = ?", claims.Id)
|
||||
if err != nil {
|
||||
@@ -92,8 +97,7 @@ func ChangeAdminPassword(c *gin.Context, oldPassword string, newPassword string)
|
||||
if admin.PasswordHash == nil {
|
||||
return errors.New(constant.SysError)
|
||||
}
|
||||
verified, _ := util.VerifyPassword(oldPassword, *admin.PasswordHash)
|
||||
if !verified {
|
||||
if !util.VerifyPassword(oldPassword, *admin.PasswordHash) {
|
||||
return errors.New(constant.WrongPassword)
|
||||
}
|
||||
hash, hashErr := util.HashPassword(newPassword)
|
||||
|
||||
+63
-14
@@ -15,10 +15,53 @@ import (
|
||||
"strings"
|
||||
)
|
||||
|
||||
// ConfigUpdate — одна пара «ключ/значение» из партии операторского API.
|
||||
type ConfigUpdate struct {
|
||||
Key string
|
||||
Value string
|
||||
}
|
||||
|
||||
func UpdateConfig(key string, value string) error {
|
||||
return dao.UpdateConfig([]string{key}, map[string]interface{}{"value": value})
|
||||
}
|
||||
|
||||
// UpdateConfigs применяет партию настроек целиком или не применяет вовсе.
|
||||
//
|
||||
// Проверка значений в неё не входит намеренно: партия обязана быть проверена
|
||||
// ПОЛНОСТЬЮ до открытия транзакции. Транзакция, внутри которой ещё может
|
||||
// возникнуть отказ по содержимому, — это откат вместо отказа, то есть лишняя
|
||||
// работа с базой на каждом неверно заполненном поле формы.
|
||||
func UpdateConfigs(updates []ConfigUpdate) error {
|
||||
if len(updates) == 0 {
|
||||
return nil
|
||||
}
|
||||
return dao.WithConfigTx(func(tx dao.ConfigTx) error {
|
||||
for _, item := range updates {
|
||||
if err := tx.UpdateConfig([]string{item.Key}, map[string]interface{}{"value": item.Value}); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
})
|
||||
}
|
||||
|
||||
// ValidateConfigValue проверяет ЗНАЧЕНИЕ настройки до записи в базу.
|
||||
//
|
||||
// Раньше такой проверки не было вовсе: DTO ограничивал длину 128 символами, а
|
||||
// поле расписания в панели — el-select с allow-create, то есть строка
|
||||
// произвольная. Невалидное cron-выражение сохранялось, API отвечал успехом, а
|
||||
// планировщик при следующем старте просто логировал ошибку и продолжал без
|
||||
// джобы. Для оператора это выглядело как «настройка принята, сброс трафика
|
||||
// молча перестал работать».
|
||||
func ValidateConfigValue(key string, value string) error {
|
||||
switch key {
|
||||
case constant.ResetTrafficCron:
|
||||
return ValidateResetTrafficCron(value)
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
func GetConfig(key string) (entity.Config, error) {
|
||||
return dao.GetConfig("key = ?", key)
|
||||
}
|
||||
@@ -27,23 +70,26 @@ func ListConfig(keys []string) ([]entity.Config, error) {
|
||||
return dao.ListConfig("key in ?", keys)
|
||||
}
|
||||
|
||||
// GetHysteria2Config читает ТОЛЬКО /etc/hysteria/config.yaml.
|
||||
//
|
||||
// Ветки «сначала посмотреть в SQLite, а если пусто — в файл» здесь больше нет.
|
||||
// Ключ HYSTERIA2_CONFIG остался от предыдущего поколения, где панель сама
|
||||
// владела серверным конфигом. В HY2XS владелец ровно один — install-оркестратор,
|
||||
// маршруты записи конфига удалены, и писателя у этого ключа не осталось: clean
|
||||
// install создавал его пустым, и пустым он оставался навсегда.
|
||||
//
|
||||
// Опасна была не бесполезность, а приоритет: БД читалась ПЕРВОЙ. Любое
|
||||
// значение, попавшее в неё в обход продукта, молча становилось тем, что панель
|
||||
// показывает оператору и из чего генерирует клиентские ссылки, пока Hysteria
|
||||
// продолжала работать по файлу. То есть ключ был готовым вторым источником
|
||||
// истины — ровно тем, что проект последовательно убирает.
|
||||
func GetHysteria2Config() (bo.Hysteria2ServerConfig, error) {
|
||||
var serverConfig bo.Hysteria2ServerConfig
|
||||
config, err := dao.GetConfig("key = ?", constant.Hysteria2Config)
|
||||
content, err := os.ReadFile(constant.Hysteria2ConfigPath)
|
||||
if err != nil {
|
||||
return serverConfig, err
|
||||
}
|
||||
if config.Value == nil || strings.TrimSpace(*config.Value) == "" {
|
||||
content, readErr := os.ReadFile(constant.Hysteria2ConfigPath)
|
||||
if readErr != nil {
|
||||
return serverConfig, readErr
|
||||
}
|
||||
if err = yaml.Unmarshal(content, &serverConfig); err != nil {
|
||||
return serverConfig, err
|
||||
}
|
||||
return serverConfig, nil
|
||||
}
|
||||
if err = yaml.Unmarshal([]byte(*config.Value), &serverConfig); err != nil {
|
||||
if err = yaml.Unmarshal(content, &serverConfig); err != nil {
|
||||
return serverConfig, err
|
||||
}
|
||||
return serverConfig, nil
|
||||
@@ -54,15 +100,18 @@ func GetHysteria2ApiPort() (int64, error) {
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
// Сообщение передаётся аргументом, а не форматной строкой: значение
|
||||
// приходит из /etc/hysteria/config.yaml, и знак процента в нём превращал
|
||||
// запись журнала в мусор вида `%!s(MISSING)`.
|
||||
if hysteria2Config.TrafficStats == nil || hysteria2Config.TrafficStats.Listen == nil {
|
||||
errMsg := "hysteria2 Traffic Stats API (HTTP) Listen is nil"
|
||||
logrus.Errorf(errMsg)
|
||||
logrus.Errorf("%s", errMsg)
|
||||
return 0, errors.New(errMsg)
|
||||
}
|
||||
apiPort, err := parseTrafficStatsPort(*hysteria2Config.TrafficStats.Listen)
|
||||
if err != nil {
|
||||
errMsg := fmt.Sprintf("apiPort: %s is invalid: %v", *hysteria2Config.TrafficStats.Listen, err)
|
||||
logrus.Errorf(errMsg)
|
||||
logrus.Errorf("%s", errMsg)
|
||||
return 0, errors.New(errMsg)
|
||||
}
|
||||
return apiPort, nil
|
||||
|
||||
@@ -0,0 +1,244 @@
|
||||
package service
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"github.com/robfig/cron/v3"
|
||||
"github.com/sirupsen/logrus"
|
||||
"hy2xs-admin/dao"
|
||||
"hy2xs-admin/model/constant"
|
||||
)
|
||||
|
||||
// Планировщик принадлежит ПРОЦЕССУ, а не HTTP-серверу.
|
||||
//
|
||||
// Что было. InitCron жил в middleware, вызывался из runServer и на каждом
|
||||
// вызове создавал новый cron.New(). Ссылка на планировщик никуда не
|
||||
// сохранялась, а releaseResource() закрывал только SQLite и Hysteria —
|
||||
// cron.Stop() не вызывался нигде. При этом смена RESET_TRAFFIC_CRON делала
|
||||
// StopServer(), из-за чего runServer возвращался, а точка входа в cmd.go
|
||||
// крутила его в `for {}` и запускала всё заново.
|
||||
//
|
||||
// Итог: каждая смена расписания добавляла ЦЕЛЫЙ дублирующий набор джоб, а
|
||||
// старое расписание сброса трафика продолжало работать. После двух правок
|
||||
// «@monthly → @weekly → @monthly» на процессе висели три планировщика,
|
||||
// утроенный CollectMetricsSnapshot и три разных расписания сброса
|
||||
// одновременно. Плюс окно, в котором джобы старого планировщика били в уже
|
||||
// закрытое соединение SQLite: releaseResource() отрабатывал раньше, чем
|
||||
// следующий runServer успевал открыть базу.
|
||||
//
|
||||
// Правильная граница: фиксированные джобы регистрируются один раз за жизнь
|
||||
// процесса, а расписание сброса трафика перепланируется на месте по своему
|
||||
// EntryID. HTTP-сервер к смене настройки отношения не имеет вообще.
|
||||
|
||||
// cronShutdownTimeout ограничивает ожидание уже запущенных джоб при остановке.
|
||||
// systemd по умолчанию даёт юниту 90 секунд, так что запас есть.
|
||||
const cronShutdownTimeout = 10 * time.Second
|
||||
|
||||
var (
|
||||
cronMu sync.Mutex
|
||||
cronScheduler *cron.Cron
|
||||
resetTrafficEntryID cron.EntryID
|
||||
|
||||
// cronOwnedJobs учитывает джобы, запущенные ВНЕ расписания.
|
||||
//
|
||||
// Стартовая уборка статистики намеренно выполняется в фоне: на большой базе
|
||||
// она заметно долгая, и держать на ней запуск сервиса незачем. Но
|
||||
// cron.Stop() ждёт только то, что запустил сам планировщик, поэтому
|
||||
// необслуженная горутина переживала закрытие SQLite — ровно та же болезнь,
|
||||
// от которой лечится весь этот файл, только меньшего масштаба.
|
||||
cronOwnedJobs sync.WaitGroup
|
||||
)
|
||||
|
||||
// ValidateResetTrafficCron проверяет выражение ТЕМ ЖЕ парсером, которым его
|
||||
// потом будет разбирать runtime.
|
||||
//
|
||||
// cron.New() без опций собирает parser из Minute|Hour|Dom|Month|Dow|Descriptor,
|
||||
// и ровно его же использует cron.ParseStandard. Поэтому «валидно на входе API»
|
||||
// и «планируется в рантайме» здесь не могут разойтись — а разойтись они могли
|
||||
// бы, если бы валидация была написана собственной регуляркой.
|
||||
//
|
||||
// Пустая строка — легальное значение и означает «автоматический сброс
|
||||
// выключен»: в панели поле clearable, и оператор имеет право его очистить.
|
||||
func ValidateResetTrafficCron(expression string) error {
|
||||
trimmed := strings.TrimSpace(expression)
|
||||
if trimmed == "" {
|
||||
return nil
|
||||
}
|
||||
if _, err := cron.ParseStandard(trimmed); err != nil {
|
||||
return fmt.Errorf("%s: невалидное cron-выражение %q: %v", constant.ResetTrafficCron, expression, err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// InitCron поднимает единственный планировщик процесса.
|
||||
func InitCron() error {
|
||||
cronMu.Lock()
|
||||
defer cronMu.Unlock()
|
||||
|
||||
if cronScheduler != nil {
|
||||
return errors.New("cron scheduler is already running")
|
||||
}
|
||||
|
||||
c := cron.New(cron.WithLocation(time.Now().Location()))
|
||||
|
||||
fixedJobs := []struct {
|
||||
name string
|
||||
spec string
|
||||
job func()
|
||||
}{
|
||||
{"CronHandleAccount", "@every 30s", CronHandleAccount},
|
||||
{"CollectMetricsSnapshot", "@every 10s", CollectMetricsSnapshot},
|
||||
{"CleanupStatsRetention", "@every 1h", CleanupStatsRetention},
|
||||
}
|
||||
for _, fixed := range fixedJobs {
|
||||
if _, err := c.AddFunc(fixed.spec, fixed.job); err != nil {
|
||||
logrus.Errorf("cron add func %s err: %v", fixed.name, err)
|
||||
return fmt.Errorf("cron add func %s err", fixed.name)
|
||||
}
|
||||
}
|
||||
|
||||
expression, err := storedResetTrafficCron()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if expression != "" {
|
||||
id, addErr := c.AddFunc(expression, CronResetTraffic)
|
||||
if addErr != nil {
|
||||
// Старт НЕ прерывается, и это осознанное решение.
|
||||
//
|
||||
// Панель отдаёт не только операторский UI: на ней же висит
|
||||
// /internal/hysteria/auth, куда Hysteria ходит при каждом
|
||||
// подключении пира. Отказ старта из-за испорченной строки
|
||||
// расписания положил бы подключения пользователей — цена
|
||||
// несопоставима с отключённым плановым сбросом счётчиков.
|
||||
//
|
||||
// Молчаливой деградации при этом нет: запись через API теперь
|
||||
// валидируется тем же парсером, поэтому попасть сюда можно только
|
||||
// правкой базы в обход продукта, и об этом пишется ERROR.
|
||||
logrus.Errorf(
|
||||
"cron: сохранённое %s=%q невалидно (%v); плановый сброс трафика выключен до исправления настройки",
|
||||
constant.ResetTrafficCron, expression, addErr,
|
||||
)
|
||||
} else {
|
||||
resetTrafficEntryID = id
|
||||
}
|
||||
}
|
||||
|
||||
cronOwnedJobs.Add(1)
|
||||
go func() {
|
||||
defer cronOwnedJobs.Done()
|
||||
CleanupStatsRetention()
|
||||
}()
|
||||
|
||||
c.Start()
|
||||
cronScheduler = c
|
||||
return nil
|
||||
}
|
||||
|
||||
// RescheduleResetTraffic переносит джобу сброса трафика на новое расписание.
|
||||
//
|
||||
// HTTP-сервер здесь не участвует. Раньше единственным способом применить новое
|
||||
// расписание был перезапуск процесса через StopServer(), и именно он и плодил
|
||||
// планировщики.
|
||||
func RescheduleResetTraffic(expression string) error {
|
||||
if err := ValidateResetTrafficCron(expression); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
cronMu.Lock()
|
||||
defer cronMu.Unlock()
|
||||
|
||||
if cronScheduler == nil {
|
||||
return errors.New("cron scheduler is not running")
|
||||
}
|
||||
|
||||
// Старая запись снимается всегда, даже если новая не будет добавлена:
|
||||
// пустое выражение означает «сброс выключен», а не «оставить как было».
|
||||
if resetTrafficEntryID != 0 {
|
||||
cronScheduler.Remove(resetTrafficEntryID)
|
||||
resetTrafficEntryID = 0
|
||||
}
|
||||
|
||||
trimmed := strings.TrimSpace(expression)
|
||||
if trimmed == "" {
|
||||
return nil
|
||||
}
|
||||
|
||||
// Ошибка здесь уже невозможна: выражение прошло тот же парсер выше.
|
||||
// Проверка остаётся, чтобы расхождение двух парсеров не превратилось в
|
||||
// молча пропавшую джобу.
|
||||
id, err := cronScheduler.AddFunc(trimmed, CronResetTraffic)
|
||||
if err != nil {
|
||||
return fmt.Errorf("%s: не удалось запланировать %q: %v", constant.ResetTrafficCron, expression, err)
|
||||
}
|
||||
resetTrafficEntryID = id
|
||||
return nil
|
||||
}
|
||||
|
||||
// StopCron останавливает планировщик и дожидается уже запущенных джоб.
|
||||
//
|
||||
// Без этого джобы продолжали работать после закрытия SQLite: каждая из них
|
||||
// ходит в базу, и остановка в обратном порядке (сначала планировщик, потом
|
||||
// соединение) — часть контракта завершения процесса.
|
||||
func StopCron() {
|
||||
cronMu.Lock()
|
||||
scheduler := cronScheduler
|
||||
cronScheduler = nil
|
||||
resetTrafficEntryID = 0
|
||||
cronMu.Unlock()
|
||||
|
||||
if scheduler == nil {
|
||||
return
|
||||
}
|
||||
|
||||
// Дожидаемся обеих групп: и джоб, запущенных планировщиком, и фоновых,
|
||||
// которые он не видит. Незавершённая джоба означает работу с базой, которую
|
||||
// releaseResource закроет сразу после возврата отсюда.
|
||||
drained := make(chan struct{})
|
||||
go func() {
|
||||
<-scheduler.Stop().Done()
|
||||
cronOwnedJobs.Wait()
|
||||
close(drained)
|
||||
}()
|
||||
|
||||
select {
|
||||
case <-drained:
|
||||
case <-time.After(cronShutdownTimeout):
|
||||
logrus.Warnf("cron: запущенные джобы не завершились за %s, продолжаем остановку", cronShutdownTimeout)
|
||||
}
|
||||
}
|
||||
|
||||
// ResetTrafficScheduled сообщает, запланирован ли сейчас сброс трафика.
|
||||
// Существует ради тестов: иначе проверить, что старая запись действительно
|
||||
// снята, а не просто добавлена рядом, можно было бы только по времени.
|
||||
func ResetTrafficScheduled() bool {
|
||||
cronMu.Lock()
|
||||
defer cronMu.Unlock()
|
||||
return resetTrafficEntryID != 0
|
||||
}
|
||||
|
||||
// CronEntryCount возвращает число активных записей планировщика.
|
||||
// Тоже ради тестов: накопление джоб — это именно рост этого числа.
|
||||
func CronEntryCount() int {
|
||||
cronMu.Lock()
|
||||
defer cronMu.Unlock()
|
||||
if cronScheduler == nil {
|
||||
return 0
|
||||
}
|
||||
return len(cronScheduler.Entries())
|
||||
}
|
||||
|
||||
func storedResetTrafficCron() (string, error) {
|
||||
config, err := dao.GetConfig("key = ?", constant.ResetTrafficCron)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
if config.Value == nil {
|
||||
return "", nil
|
||||
}
|
||||
return strings.TrimSpace(*config.Value), nil
|
||||
}
|
||||
@@ -0,0 +1,197 @@
|
||||
package service
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"hy2xs-admin/dao"
|
||||
"hy2xs-admin/model/constant"
|
||||
)
|
||||
|
||||
// Число фиксированных джоб планировщика: CronHandleAccount,
|
||||
// CollectMetricsSnapshot, CleanupStatsRetention. Записано числом намеренно —
|
||||
// тест обязан заметить и появление новой джобы, и потерю существующей.
|
||||
const fixedCronJobCount = 3
|
||||
|
||||
func startTestCron(t *testing.T, resetTrafficExpression string) {
|
||||
t.Helper()
|
||||
|
||||
newTestDB(t)
|
||||
if err := dao.UpdateConfig(
|
||||
[]string{constant.ResetTrafficCron},
|
||||
map[string]interface{}{"value": resetTrafficExpression},
|
||||
); err != nil {
|
||||
t.Fatalf("не удалось записать %s: %v", constant.ResetTrafficCron, err)
|
||||
}
|
||||
|
||||
if err := InitCron(); err != nil {
|
||||
t.Fatalf("InitCron: %v", err)
|
||||
}
|
||||
t.Cleanup(StopCron)
|
||||
}
|
||||
|
||||
// Главная регрессия P0: смена расписания не имеет права добавлять джобы.
|
||||
//
|
||||
// Раньше применение новой настройки шло через StopServer() и повторный
|
||||
// runServer, а InitCron на каждом вызове создавал новый cron.New() и нигде его
|
||||
// не сохранял. Старый планировщик никто не останавливал, поэтому после каждой
|
||||
// правки на процессе оставался ЦЕЛЫЙ дублирующий набор джоб, а старое
|
||||
// расписание сброса трафика продолжало срабатывать.
|
||||
func TestRescheduleResetTrafficDoesNotAccumulateJobs(t *testing.T) {
|
||||
startTestCron(t, "@monthly")
|
||||
|
||||
initial := CronEntryCount()
|
||||
if initial != fixedCronJobCount+1 {
|
||||
t.Fatalf("после старта ожидалось %d записей, получено %d", fixedCronJobCount+1, initial)
|
||||
}
|
||||
|
||||
for _, expression := range []string{"@weekly", "@monthly", "0 3 * * *", "@daily"} {
|
||||
if err := RescheduleResetTraffic(expression); err != nil {
|
||||
t.Fatalf("RescheduleResetTraffic(%q): %v", expression, err)
|
||||
}
|
||||
if count := CronEntryCount(); count != initial {
|
||||
t.Fatalf("после смены расписания на %q записей стало %d, ожидалось %d", expression, count, initial)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Пустое выражение означает «автоматический сброс выключен», а не «оставить
|
||||
// как было»: поле в панели clearable, и оператор имеет право его очистить.
|
||||
func TestRescheduleResetTrafficWithEmptyExpressionDisablesJob(t *testing.T) {
|
||||
startTestCron(t, "@monthly")
|
||||
|
||||
if !ResetTrafficScheduled() {
|
||||
t.Fatal("после старта с непустым расписанием джоба сброса не запланирована")
|
||||
}
|
||||
|
||||
if err := RescheduleResetTraffic(" "); err != nil {
|
||||
t.Fatalf("RescheduleResetTraffic(пусто): %v", err)
|
||||
}
|
||||
if ResetTrafficScheduled() {
|
||||
t.Fatal("пустое выражение не сняло джобу сброса трафика")
|
||||
}
|
||||
if count := CronEntryCount(); count != fixedCronJobCount {
|
||||
t.Fatalf("после отключения сброса ожидалось %d записей, получено %d", fixedCronJobCount, count)
|
||||
}
|
||||
|
||||
// Включение обратно должно работать без перезапуска процесса.
|
||||
if err := RescheduleResetTraffic("@weekly"); err != nil {
|
||||
t.Fatalf("повторное включение: %v", err)
|
||||
}
|
||||
if !ResetTrafficScheduled() {
|
||||
t.Fatal("джоба сброса не вернулась после повторного включения")
|
||||
}
|
||||
}
|
||||
|
||||
// Невалидное выражение не имеет права ни изменить планировщик, ни пройти
|
||||
// молча: раньше ошибка AddFunc только логировалась, и сброс трафика тихо
|
||||
// исчезал.
|
||||
func TestRescheduleResetTrafficRejectsInvalidExpression(t *testing.T) {
|
||||
startTestCron(t, "@monthly")
|
||||
|
||||
before := CronEntryCount()
|
||||
|
||||
if err := RescheduleResetTraffic("какая-нибудь ерунда"); err == nil {
|
||||
t.Fatal("невалидное выражение принято")
|
||||
}
|
||||
if after := CronEntryCount(); after != before {
|
||||
t.Fatalf("отклонённое выражение изменило планировщик: было %d записей, стало %d", before, after)
|
||||
}
|
||||
if !ResetTrafficScheduled() {
|
||||
t.Fatal("отклонённое выражение сняло действующую джобу")
|
||||
}
|
||||
}
|
||||
|
||||
// Валидация обязана пользоваться ТЕМ ЖЕ парсером, что и планировщик. Набор
|
||||
// проверяет обе стороны: то, что cron умеет, должно приниматься, а то, что не
|
||||
// умеет, — отклоняться до записи в базу.
|
||||
func TestValidateResetTrafficCronMatchesSchedulerParser(t *testing.T) {
|
||||
valid := []string{
|
||||
"",
|
||||
" ",
|
||||
"@monthly",
|
||||
"@weekly",
|
||||
"@daily",
|
||||
"@hourly",
|
||||
"@every 1h30m",
|
||||
"0 0 * * *",
|
||||
"*/15 * * * *",
|
||||
"0 3 1 * 1",
|
||||
}
|
||||
for _, expression := range valid {
|
||||
if err := ValidateResetTrafficCron(expression); err != nil {
|
||||
t.Errorf("валидное выражение %q отклонено: %v", expression, err)
|
||||
}
|
||||
}
|
||||
|
||||
invalid := []string{
|
||||
"какая-нибудь ерунда",
|
||||
"@yearly extra",
|
||||
"* * * *",
|
||||
"* * * * * *",
|
||||
"99 * * * *",
|
||||
"@every",
|
||||
"@every банан",
|
||||
"- - - - -",
|
||||
}
|
||||
for _, expression := range invalid {
|
||||
if err := ValidateResetTrafficCron(expression); err == nil {
|
||||
t.Errorf("невалидное выражение %q принято", expression)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Невалидное значение в базе не имеет права уронить старт: на панели висит
|
||||
// /internal/hysteria/auth, и отказ старта из-за строки расписания положил бы
|
||||
// подключения пользователей.
|
||||
func TestInitCronSurvivesInvalidStoredExpression(t *testing.T) {
|
||||
startTestCron(t, "совершенно невалидная строка")
|
||||
|
||||
if ResetTrafficScheduled() {
|
||||
t.Fatal("невалидное выражение из базы было запланировано")
|
||||
}
|
||||
if count := CronEntryCount(); count != fixedCronJobCount {
|
||||
t.Fatalf("фиксированные джобы не поднялись: ожидалось %d записей, получено %d", fixedCronJobCount, count)
|
||||
}
|
||||
|
||||
// Оператор обязан иметь возможность починить настройку через API, без
|
||||
// перезапуска сервиса.
|
||||
if err := RescheduleResetTraffic("@weekly"); err != nil {
|
||||
t.Fatalf("исправление расписания: %v", err)
|
||||
}
|
||||
if !ResetTrafficScheduled() {
|
||||
t.Fatal("исправленное расписание не применилось")
|
||||
}
|
||||
}
|
||||
|
||||
// Планировщик принадлежит процессу: второй InitCron без остановки первого —
|
||||
// это ровно тот сценарий, который и создавал дубликаты.
|
||||
func TestInitCronRefusesSecondScheduler(t *testing.T) {
|
||||
startTestCron(t, "@monthly")
|
||||
|
||||
if err := InitCron(); err == nil {
|
||||
t.Fatal("второй планировщик поднялся поверх работающего")
|
||||
}
|
||||
if count := CronEntryCount(); count != fixedCronJobCount+1 {
|
||||
t.Fatalf("отклонённый повторный старт изменил планировщик: %d записей", count)
|
||||
}
|
||||
}
|
||||
|
||||
func TestStopCronIsIdempotent(t *testing.T) {
|
||||
startTestCron(t, "@monthly")
|
||||
|
||||
StopCron()
|
||||
if count := CronEntryCount(); count != 0 {
|
||||
t.Fatalf("после остановки осталось %d записей", count)
|
||||
}
|
||||
if ResetTrafficScheduled() {
|
||||
t.Fatal("после остановки джоба сброса числится запланированной")
|
||||
}
|
||||
|
||||
// Второй вызов не должен паниковать: StopCron стоит в defer runServer и
|
||||
// может быть вызван повторно на пути обработки ошибки.
|
||||
StopCron()
|
||||
|
||||
if err := RescheduleResetTraffic("@weekly"); err == nil {
|
||||
t.Fatal("перепланирование на остановленном планировщике не отклонено")
|
||||
}
|
||||
}
|
||||
@@ -3,9 +3,6 @@ package service
|
||||
import (
|
||||
"errors"
|
||||
|
||||
"github.com/sirupsen/logrus"
|
||||
"hy2xs-admin/dao"
|
||||
"hy2xs-admin/model/constant"
|
||||
"hy2xs-admin/util"
|
||||
)
|
||||
|
||||
@@ -13,19 +10,19 @@ import (
|
||||
// Панель умеет только наблюдать состояние: функций Start/Stop/Restart и
|
||||
// смены версии здесь нет намеренно, а не «временно отключены».
|
||||
|
||||
// InitHysteria2 проверяет единственное, что панели действительно нужно от
|
||||
// Hysteria на старте: наличие бинарника, версию которого показывает дашборд и
|
||||
// у которого спрашивает состояние Hysteria2IsRunning.
|
||||
//
|
||||
// Чтения HYSTERIA2_ENABLE здесь больше нет. Ключ был последним следом модели,
|
||||
// в которой панель сама запускала и останавливала Hysteria: clean install
|
||||
// создавал его со значением "0", записать "1" было некому, а вся ветка
|
||||
// сводилась к строке в журнале. Настройка, которая ничем не управляет, но
|
||||
// выглядит выключателем, хуже отсутствующей.
|
||||
func InitHysteria2() error {
|
||||
if !util.Exists(util.GetHysteria2BinPath()) {
|
||||
return errors.New("systemd-managed hysteria binary not found")
|
||||
}
|
||||
|
||||
config, err := dao.GetConfig("key = ?", constant.Hysteria2Enable)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if *config.Value == "1" {
|
||||
logrus.Infof("hysteria2 lifecycle is managed by systemd in HY2XS production package")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
|
||||
@@ -148,15 +148,8 @@ func Hysteria2Url(accountId int64) (string, error) {
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
hysteria2ConfigRemark, err := dao.GetConfig("key = ?", constant.Hysteria2ConfigRemark)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
|
||||
remark := ""
|
||||
if hysteria2ConfigRemark.Value != nil {
|
||||
remark = *hysteria2ConfigRemark.Value
|
||||
}
|
||||
remark := shareRemark(peer.Name, hostname)
|
||||
|
||||
obfs := hysteria2Config.ObfsShare()
|
||||
sni := resolveShareSni(hysteria2Config.AcmeDomain(), hostname)
|
||||
@@ -172,6 +165,27 @@ func Hysteria2Url(accountId int64) (string, error) {
|
||||
return buildHysteria2Url(secret, hostname, port, obfs, sni, remark), nil
|
||||
}
|
||||
|
||||
// shareRemark даёт имя профиля, которое клиент показывает в списке серверов.
|
||||
//
|
||||
// Раньше оно бралось из HYSTERIA2_CONFIG_REMARK — пустой строки в таблице
|
||||
// `config`, которую clean install создавал один раз и которую никто никогда не
|
||||
// записывал. То есть fragment у ссылки отсутствовал всегда, и все выданные
|
||||
// ссылки выглядели в клиенте одинаково.
|
||||
//
|
||||
// Теперь значение выводится детерминированно из имени пира: у панели с
|
||||
// несколькими пирами это ровно то различие, которое пользователю и нужно
|
||||
// видеть, и оно не требует ни одной дополнительной настройки. Fallback на
|
||||
// публичный хост нужен для пира без имени — база это допускает (name имеет
|
||||
// DEFAULT ''), а ссылка без имени профиля хуже, чем ссылка с именем сервера.
|
||||
func shareRemark(peerName *string, hostname string) string {
|
||||
if peerName != nil {
|
||||
if name := strings.TrimSpace(*peerName); name != "" {
|
||||
return name
|
||||
}
|
||||
}
|
||||
return hostname
|
||||
}
|
||||
|
||||
// isShareableObfsType перечисляет типы обфускации, которые официальная
|
||||
// URI-схема Hysteria умеет передавать клиенту.
|
||||
func isShareableObfsType(obfsType string) bool {
|
||||
|
||||
@@ -8,7 +8,6 @@ import (
|
||||
|
||||
"gopkg.in/yaml.v3"
|
||||
|
||||
"hy2xs-admin/dao"
|
||||
"hy2xs-admin/model/constant"
|
||||
)
|
||||
|
||||
@@ -21,19 +20,17 @@ const RedactedPlaceholder = "<redacted>"
|
||||
// Это отдельный слой от GetHysteria2Config намеренно: типизированная модель
|
||||
// отражает известные HY2XS поля и используется для отображения, а сырой YAML
|
||||
// нужен там, где нельзя потерять поля, о которых HY2XS пока не знает.
|
||||
//
|
||||
// Источник ровно один — файл. Ветка «сначала SQLite, потом файл» удалена
|
||||
// вместе с ключом HYSTERIA2_CONFIG: см. GetHysteria2Config в service/config.go.
|
||||
// Здесь у неё было дополнительное следствие — выгрузка «фактического
|
||||
// серверного конфига» могла отдать оператору документ, по которому Hysteria
|
||||
// никогда не работала.
|
||||
func GetRawHysteria2Config() (string, error) {
|
||||
config, err := dao.GetConfig("key = ?", constant.Hysteria2Config)
|
||||
content, err := os.ReadFile(constant.Hysteria2ConfigPath)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
if config.Value != nil && strings.TrimSpace(*config.Value) != "" {
|
||||
return *config.Value, nil
|
||||
}
|
||||
|
||||
content, readErr := os.ReadFile(constant.Hysteria2ConfigPath)
|
||||
if readErr != nil {
|
||||
return "", readErr
|
||||
}
|
||||
return string(content), nil
|
||||
}
|
||||
|
||||
|
||||
@@ -4,8 +4,10 @@ import (
|
||||
"bufio"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"hy2xs-admin/model/constant"
|
||||
"hy2xs-admin/model/vo"
|
||||
"hy2xs-admin/util"
|
||||
"os"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
@@ -58,6 +60,22 @@ func ReadHysteriaJournalLogs(numLine int) ([]vo.LogHysteria2Vo, int, error) {
|
||||
return result, len(result), nil
|
||||
}
|
||||
|
||||
// ExportAdminLog отдаёт журнал самой админки, вырезав из него секреты.
|
||||
//
|
||||
// Раньше этот файл выгружался как есть, через c.File: чужой журнал продукт
|
||||
// санитизировал, а собственный — нет. Обоснования у асимметрии не было, а цена
|
||||
// известна поимённо: пока bootstrap-пароль администратора печатался в лог
|
||||
// warning'ом, обычная кнопка «выгрузить журнал» отдавала его открытым текстом.
|
||||
// Сам warning убран (см. dao/sqlite.go), но защита от следующего такого места
|
||||
// должна стоять и на выходе.
|
||||
func ExportAdminLog() (string, error) {
|
||||
content, err := os.ReadFile(constant.SystemLogPath)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
return SanitizeLogText(string(content)), nil
|
||||
}
|
||||
|
||||
// ExportHysteriaJournalLogs отдаёт журнал Hysteria оператору.
|
||||
//
|
||||
// Файл покидает сервер, поэтому проходит тот же санитайз, что и остальные
|
||||
|
||||
+87
-36
@@ -2,59 +2,110 @@ package service
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"github.com/gin-gonic/gin"
|
||||
"github.com/golang-jwt/jwt"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/golang-jwt/jwt/v5"
|
||||
"hy2xs-admin/dao"
|
||||
"hy2xs-admin/model/bo"
|
||||
"hy2xs-admin/model/constant"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Токены подписываются и проверяются библиотекой golang-jwt/jwt/v5.
|
||||
//
|
||||
// Переход с v3 не косметический. У `github.com/golang-jwt/jwt` v3.2.2 есть
|
||||
// GO-2025-3553 (чрезмерное выделение памяти при разборе заголовка), и у неё
|
||||
// НЕТ исправленной версии в ветке v3: `Fixed in: N/A`. Уязвимый код
|
||||
// достигается из ParseToken, то есть с неаутентифицированного запроса — любой,
|
||||
// кто может обратиться к панели, попадает в него до всякой проверки прав.
|
||||
// Обновить здесь было нечего, поэтому лечится только сменой мажорной ветки.
|
||||
//
|
||||
// Заодно закрыт второй, тихий недостаток прежней реализации: keyfunc возвращал
|
||||
// ключ, НЕ проверяя алгоритм подписи. Разбор без ограничения набора алгоритмов
|
||||
// — это тот класс ошибок, из которого растёт подмена алгоритма; ниже стоит
|
||||
// jwt.WithValidMethods, и допустимый алгоритм ровно один.
|
||||
|
||||
const TokenExpireDuration = time.Hour * 24
|
||||
|
||||
// tokenIssuer попадает и в подпись, и в проверку: токен, выписанный не нами,
|
||||
// не должен разбираться как наш даже при совпадении ключа.
|
||||
const tokenIssuer = "hy2xs-admin"
|
||||
|
||||
type MyClaims struct {
|
||||
Admin bo.AccountBo `json:"admin"`
|
||||
jwt.StandardClaims
|
||||
jwt.RegisteredClaims
|
||||
}
|
||||
|
||||
func GenToken(accountBo bo.AccountBo) (string, error) {
|
||||
c := MyClaims{
|
||||
Admin: accountBo,
|
||||
StandardClaims: jwt.StandardClaims{
|
||||
ExpiresAt: time.Now().Add(TokenExpireDuration).Unix(),
|
||||
Issuer: "hy2xs-admin",
|
||||
},
|
||||
}
|
||||
config, err := dao.GetConfig("key = ?", constant.JwtSecret)
|
||||
if err != nil {
|
||||
return "", errors.New(constant.SysError)
|
||||
}
|
||||
token := jwt.NewWithClaims(jwt.SigningMethodHS256, c)
|
||||
return token.SignedString([]byte(*config.Value))
|
||||
}
|
||||
|
||||
func ParseToken(tokenString string) (*MyClaims, error) {
|
||||
func jwtSecret() ([]byte, error) {
|
||||
config, err := dao.GetConfig("key = ?", constant.JwtSecret)
|
||||
if err != nil {
|
||||
return nil, errors.New(constant.SysError)
|
||||
}
|
||||
token, err := jwt.ParseWithClaims(tokenString, &MyClaims{}, func(token *jwt.Token) (i interface{}, err error) {
|
||||
return []byte(*config.Value), nil
|
||||
})
|
||||
if err != nil {
|
||||
return nil, errors.New(constant.IllegalTokenError)
|
||||
if config.Value == nil || strings.TrimSpace(*config.Value) == "" {
|
||||
// Подпись пустым ключом дала бы токены, которые подделывает кто угодно.
|
||||
// Раньше значение разыменовывалось без проверки: пустой JWT_SECRET
|
||||
// молча превращался в ключ нулевой длины.
|
||||
return nil, errors.New(constant.SysError)
|
||||
}
|
||||
if claims, ok := token.Claims.(*MyClaims); ok && token.Valid {
|
||||
return claims, nil
|
||||
}
|
||||
return nil, errors.New(constant.TokenExpiredError)
|
||||
return []byte(*config.Value), nil
|
||||
}
|
||||
|
||||
func GetToken(c *gin.Context) string {
|
||||
tokenStr := c.Request.Header.Get("Authorization")
|
||||
if tokenStr == "" {
|
||||
return ""
|
||||
func GenToken(accountBo bo.AccountBo) (string, error) {
|
||||
secret, err := jwtSecret()
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
return strings.SplitN(tokenStr, " ", 2)[1]
|
||||
|
||||
now := time.Now()
|
||||
claims := MyClaims{
|
||||
Admin: accountBo,
|
||||
RegisteredClaims: jwt.RegisteredClaims{
|
||||
ExpiresAt: jwt.NewNumericDate(now.Add(TokenExpireDuration)),
|
||||
IssuedAt: jwt.NewNumericDate(now),
|
||||
NotBefore: jwt.NewNumericDate(now),
|
||||
Issuer: tokenIssuer,
|
||||
},
|
||||
}
|
||||
|
||||
return jwt.NewWithClaims(jwt.SigningMethodHS256, claims).SignedString(secret)
|
||||
}
|
||||
|
||||
func ParseToken(tokenString string) (*MyClaims, error) {
|
||||
secret, err := jwtSecret()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
token, err := jwt.ParseWithClaims(
|
||||
tokenString,
|
||||
&MyClaims{},
|
||||
func(*jwt.Token) (interface{}, error) { return secret, nil },
|
||||
// Допустимый алгоритм ровно один. Без этого ограничения набор
|
||||
// алгоритмов задаёт сам токен, то есть недоверенный вход.
|
||||
jwt.WithValidMethods([]string{jwt.SigningMethodHS256.Alg()}),
|
||||
jwt.WithIssuer(tokenIssuer),
|
||||
// Токен без срока жизни не должен считаться валидным бессрочным.
|
||||
jwt.WithExpirationRequired(),
|
||||
)
|
||||
if err != nil {
|
||||
if errors.Is(err, jwt.ErrTokenExpired) {
|
||||
return nil, errors.New(constant.TokenExpiredError)
|
||||
}
|
||||
return nil, errors.New(constant.IllegalTokenError)
|
||||
}
|
||||
|
||||
claims, ok := token.Claims.(*MyClaims)
|
||||
if !ok || !token.Valid {
|
||||
return nil, errors.New(constant.IllegalTokenError)
|
||||
}
|
||||
return claims, nil
|
||||
}
|
||||
|
||||
// Функции GetToken здесь больше нет.
|
||||
//
|
||||
// Она доставала токен из заголовка Authorization вторым, независимым от
|
||||
// middleware.JWTHandler способом — и делала это через
|
||||
// strings.SplitN(tokenStr, " ", 2)[1], то есть паниковала на заголовке без
|
||||
// пробела: `Authorization: abc` давал index out of range. Единственный
|
||||
// потребитель — резервная ветка GetAdminInfo, которая была недостижима и
|
||||
// проверяла меньше, чем middleware. Разбор токена у продукта ровно один.
|
||||
|
||||
@@ -0,0 +1,204 @@
|
||||
package service
|
||||
|
||||
import (
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/golang-jwt/jwt/v5"
|
||||
"hy2xs-admin/dao"
|
||||
"hy2xs-admin/model/bo"
|
||||
"hy2xs-admin/model/constant"
|
||||
)
|
||||
|
||||
func newJwtTestDB(t *testing.T) []byte {
|
||||
t.Helper()
|
||||
|
||||
newTestDB(t)
|
||||
|
||||
secret := "test-jwt-secret-not-used-anywhere-else-0123456789"
|
||||
if err := dao.UpsertConfigValue(constant.JwtSecret, secret); err != nil {
|
||||
t.Fatalf("не удалось записать %s: %v", constant.JwtSecret, err)
|
||||
}
|
||||
return []byte(secret)
|
||||
}
|
||||
|
||||
func testAccount() bo.AccountBo {
|
||||
return bo.AccountBo{Id: 1, Username: "hy2xsadmin", Roles: []string{"admin"}, TokenVersion: 1}
|
||||
}
|
||||
|
||||
func TestGenAndParseTokenRoundTrip(t *testing.T) {
|
||||
newJwtTestDB(t)
|
||||
|
||||
token, err := GenToken(testAccount())
|
||||
if err != nil {
|
||||
t.Fatalf("GenToken: %v", err)
|
||||
}
|
||||
|
||||
claims, err := ParseToken(token)
|
||||
if err != nil {
|
||||
t.Fatalf("ParseToken: %v", err)
|
||||
}
|
||||
if claims.Admin.Id != 1 || claims.Admin.Username != "hy2xsadmin" {
|
||||
t.Fatalf("claims не совпадают: %+v", claims.Admin)
|
||||
}
|
||||
if claims.Admin.TokenVersion != 1 {
|
||||
t.Fatalf("token_version потерян: %d", claims.Admin.TokenVersion)
|
||||
}
|
||||
if claims.ExpiresAt == nil {
|
||||
t.Fatal("токен выписан без срока жизни")
|
||||
}
|
||||
}
|
||||
|
||||
// Алгоритм подписи задаётся сервером, а не токеном.
|
||||
//
|
||||
// Прежний keyfunc возвращал ключ, не глядя на token.Method: набор допустимых
|
||||
// алгоритмов фактически определял недоверенный вход. Здесь проверяется, что
|
||||
// токен, подписанный другим HMAC-алгоритмом тем же ключом, отклоняется.
|
||||
func TestParseTokenRejectsOtherSigningMethod(t *testing.T) {
|
||||
secret := newJwtTestDB(t)
|
||||
|
||||
now := time.Now()
|
||||
claims := MyClaims{
|
||||
Admin: testAccount(),
|
||||
RegisteredClaims: jwt.RegisteredClaims{
|
||||
ExpiresAt: jwt.NewNumericDate(now.Add(time.Hour)),
|
||||
IssuedAt: jwt.NewNumericDate(now),
|
||||
Issuer: tokenIssuer,
|
||||
},
|
||||
}
|
||||
signed, err := jwt.NewWithClaims(jwt.SigningMethodHS512, claims).SignedString(secret)
|
||||
if err != nil {
|
||||
t.Fatalf("не удалось подписать тестовый токен: %v", err)
|
||||
}
|
||||
|
||||
if _, err := ParseToken(signed); err == nil {
|
||||
t.Fatal("токен, подписанный HS512, принят при разрешённом только HS256")
|
||||
}
|
||||
}
|
||||
|
||||
// Токен без exp не должен считаться бессрочно валидным.
|
||||
func TestParseTokenRejectsTokenWithoutExpiration(t *testing.T) {
|
||||
secret := newJwtTestDB(t)
|
||||
|
||||
claims := MyClaims{
|
||||
Admin: testAccount(),
|
||||
RegisteredClaims: jwt.RegisteredClaims{
|
||||
IssuedAt: jwt.NewNumericDate(time.Now()),
|
||||
Issuer: tokenIssuer,
|
||||
},
|
||||
}
|
||||
signed, err := jwt.NewWithClaims(jwt.SigningMethodHS256, claims).SignedString(secret)
|
||||
if err != nil {
|
||||
t.Fatalf("не удалось подписать тестовый токен: %v", err)
|
||||
}
|
||||
|
||||
if _, err := ParseToken(signed); err == nil {
|
||||
t.Fatal("токен без exp принят")
|
||||
}
|
||||
}
|
||||
|
||||
func TestParseTokenRejectsExpiredToken(t *testing.T) {
|
||||
secret := newJwtTestDB(t)
|
||||
|
||||
past := time.Now().Add(-2 * time.Hour)
|
||||
claims := MyClaims{
|
||||
Admin: testAccount(),
|
||||
RegisteredClaims: jwt.RegisteredClaims{
|
||||
ExpiresAt: jwt.NewNumericDate(past.Add(time.Hour)),
|
||||
IssuedAt: jwt.NewNumericDate(past),
|
||||
Issuer: tokenIssuer,
|
||||
},
|
||||
}
|
||||
signed, err := jwt.NewWithClaims(jwt.SigningMethodHS256, claims).SignedString(secret)
|
||||
if err != nil {
|
||||
t.Fatalf("не удалось подписать тестовый токен: %v", err)
|
||||
}
|
||||
|
||||
_, err = ParseToken(signed)
|
||||
if err == nil {
|
||||
t.Fatal("истёкший токен принят")
|
||||
}
|
||||
if err.Error() != constant.TokenExpiredError {
|
||||
t.Errorf("истечение срока должно сообщаться отдельно, получено: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
// Токен, выписанный не нами, не должен разбираться как наш даже при совпадении
|
||||
// ключа: issuer входит в проверку.
|
||||
func TestParseTokenRejectsForeignIssuer(t *testing.T) {
|
||||
secret := newJwtTestDB(t)
|
||||
|
||||
now := time.Now()
|
||||
claims := MyClaims{
|
||||
Admin: testAccount(),
|
||||
RegisteredClaims: jwt.RegisteredClaims{
|
||||
ExpiresAt: jwt.NewNumericDate(now.Add(time.Hour)),
|
||||
IssuedAt: jwt.NewNumericDate(now),
|
||||
Issuer: "some-other-service",
|
||||
},
|
||||
}
|
||||
signed, err := jwt.NewWithClaims(jwt.SigningMethodHS256, claims).SignedString(secret)
|
||||
if err != nil {
|
||||
t.Fatalf("не удалось подписать тестовый токен: %v", err)
|
||||
}
|
||||
|
||||
if _, err := ParseToken(signed); err == nil {
|
||||
t.Fatal("токен с чужим issuer принят")
|
||||
}
|
||||
}
|
||||
|
||||
func TestParseTokenRejectsWrongSecret(t *testing.T) {
|
||||
newJwtTestDB(t)
|
||||
|
||||
now := time.Now()
|
||||
claims := MyClaims{
|
||||
Admin: testAccount(),
|
||||
RegisteredClaims: jwt.RegisteredClaims{
|
||||
ExpiresAt: jwt.NewNumericDate(now.Add(time.Hour)),
|
||||
IssuedAt: jwt.NewNumericDate(now),
|
||||
Issuer: tokenIssuer,
|
||||
},
|
||||
}
|
||||
signed, err := jwt.NewWithClaims(jwt.SigningMethodHS256, claims).SignedString([]byte("совершенно другой ключ подписи"))
|
||||
if err != nil {
|
||||
t.Fatalf("не удалось подписать тестовый токен: %v", err)
|
||||
}
|
||||
|
||||
if _, err := ParseToken(signed); err == nil {
|
||||
t.Fatal("токен, подписанный чужим ключом, принят")
|
||||
}
|
||||
}
|
||||
|
||||
func TestParseTokenRejectsGarbage(t *testing.T) {
|
||||
newJwtTestDB(t)
|
||||
|
||||
for _, value := range []string{
|
||||
"",
|
||||
"not-a-token",
|
||||
"a.b.c",
|
||||
strings.Repeat("A", 500),
|
||||
"eyJhbGciOiJub25lIiwidHlwIjoiSldUIn0.eyJhZG1pbiI6eyJpZCI6MX19.",
|
||||
} {
|
||||
if _, err := ParseToken(value); err == nil {
|
||||
t.Errorf("мусорный токен %q принят", value)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Пустой JWT_SECRET — повреждённое состояние, а не «ключ нулевой длины».
|
||||
// Раньше значение разыменовывалось без проверки, и подпись выполнялась пустым
|
||||
// ключом: такой токен подделывает кто угодно.
|
||||
func TestGenTokenRefusesEmptySecret(t *testing.T) {
|
||||
newTestDB(t)
|
||||
if err := dao.UpsertConfigValue(constant.JwtSecret, ""); err != nil {
|
||||
t.Fatalf("не удалось очистить %s: %v", constant.JwtSecret, err)
|
||||
}
|
||||
|
||||
if _, err := GenToken(testAccount()); err == nil {
|
||||
t.Fatal("токен подписан пустым ключом")
|
||||
}
|
||||
if _, err := ParseToken("whatever"); err == nil {
|
||||
t.Fatal("разбор токена с пустым ключом не отклонён")
|
||||
}
|
||||
}
|
||||
@@ -46,10 +46,40 @@ func PagePeer(peerPageDto dto.PeerPageDto) ([]vo.PeerVo, int64, error) {
|
||||
return result, total, nil
|
||||
}
|
||||
|
||||
// Пир установщика защищён во ВСЕХ путях записи, а не только в импорте.
|
||||
//
|
||||
// Что было. ReservedBootstrapPeerName проверялся исключительно в
|
||||
// applyPeerImportEntry. Обычный CRUD панели такой проверки не имел, то есть
|
||||
// ровно то, ради чего guard существует, делалось через интерфейс: секрет
|
||||
// bootstrap-admin-peer продублирован в /etc/hy2xs/bootstrap-admin.secret,
|
||||
// откуда его читает проверка machine-auth оркестратора, и смена секрета через
|
||||
// форму молча рассинхронизировала бы файл с базой. Дверей в таблицу было две,
|
||||
// а замок висел на одной.
|
||||
//
|
||||
// Границы намеренно разные для разных операций:
|
||||
//
|
||||
// идентичность и секрет — запрещены: они и есть то, что дублируется в файле;
|
||||
// удаление и отключение — разрешены: это осознанные действия оператора,
|
||||
// результат которых виден в списке пиров. Bootstrap-пир после установки
|
||||
// остаётся действующим доступом, и запрет его убрать означал бы вечный
|
||||
// неотзываемый доступ.
|
||||
var errBootstrapPeerIdentity = fmt.Errorf(
|
||||
"пир %q принадлежит установщику: его имя и секрет продублированы в "+
|
||||
"/etc/hy2xs/bootstrap-admin.secret и не могут быть изменены через панель. "+
|
||||
"Ненужный bootstrap-пир следует удалить целиком, а не переподписывать",
|
||||
ReservedBootstrapPeerName,
|
||||
)
|
||||
|
||||
func CreatePeer(peerDto dto.PeerSaveDto) (vo.PeerVo, error) {
|
||||
if peerDto.Name == nil || *peerDto.Name == "" {
|
||||
return vo.PeerVo{}, errors.New(constant.InvalidError)
|
||||
}
|
||||
// Имя зарезервировано за установщиком даже когда сам пир уже удалён:
|
||||
// иначе после удаления обычный пир мог бы занять это имя и оказаться под
|
||||
// защитой, предназначенной не ему.
|
||||
if strings.TrimSpace(*peerDto.Name) == ReservedBootstrapPeerName {
|
||||
return vo.PeerVo{}, fmt.Errorf("имя %q зарезервировано за пиром установщика", ReservedBootstrapPeerName)
|
||||
}
|
||||
if ExistPeerName(*peerDto.Name, 0) {
|
||||
return vo.PeerVo{}, errors.New(fmt.Sprintf("name %s already exists", *peerDto.Name))
|
||||
}
|
||||
@@ -94,6 +124,10 @@ func CreatePeer(peerDto dto.PeerSaveDto) (vo.PeerVo, error) {
|
||||
}
|
||||
|
||||
func UpdatePeer(id int64, peerDto dto.PeerUpdateDto) error {
|
||||
if err := assertBootstrapPeerIdentityUnchanged(id, peerDto); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
updates := map[string]interface{}{}
|
||||
if peerDto.Name != nil && *peerDto.Name != "" {
|
||||
updates["name"] = *peerDto.Name
|
||||
@@ -128,6 +162,47 @@ func UpdatePeer(id int64, peerDto dto.PeerUpdateDto) error {
|
||||
return dao.UpdatePeer([]int64{id}, updates)
|
||||
}
|
||||
|
||||
// assertBootstrapPeerIdentityUnchanged запрещает менять то, что продублировано
|
||||
// в /etc/hy2xs/bootstrap-admin.secret, и занимать зарезервированное имя.
|
||||
func assertBootstrapPeerIdentityUnchanged(id int64, peerDto dto.PeerUpdateDto) error {
|
||||
// Переименование ЛЮБОГО пира в зарезервированное имя запрещено отдельно от
|
||||
// проверки цели: UNIQUE(name) закрывает этот путь только пока bootstrap-пир
|
||||
// существует.
|
||||
if peerDto.Name != nil && strings.TrimSpace(*peerDto.Name) == ReservedBootstrapPeerName {
|
||||
existing, err := dao.GetPeer("id = ?", id)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if existing.Name == nil || *existing.Name != ReservedBootstrapPeerName {
|
||||
return fmt.Errorf("имя %q зарезервировано за пиром установщика", ReservedBootstrapPeerName)
|
||||
}
|
||||
}
|
||||
|
||||
existing, err := dao.GetPeer("id = ?", id)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if existing.Name == nil || *existing.Name != ReservedBootstrapPeerName {
|
||||
return nil
|
||||
}
|
||||
|
||||
if peerDto.Name != nil && strings.TrimSpace(*peerDto.Name) != "" &&
|
||||
strings.TrimSpace(*peerDto.Name) != ReservedBootstrapPeerName {
|
||||
return errBootstrapPeerIdentity
|
||||
}
|
||||
if peerDto.Secret != nil && strings.TrimSpace(*peerDto.Secret) != "" {
|
||||
return errBootstrapPeerIdentity
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// DeletePeer удаляет пира, включая bootstrap-пира установщика.
|
||||
//
|
||||
// Удаление намеренно НЕ запрещено. Bootstrap-пир после установки — обычный
|
||||
// действующий доступ, секрет которого лежит ещё и в файле на диске; оператор
|
||||
// обязан иметь возможность его отозвать. В отличие от смены секрета, удаление
|
||||
// не создаёт расхождения между базой и файлом: пира просто нет, и это видно в
|
||||
// списке.
|
||||
func DeletePeer(id int64) error { return dao.DeletePeer([]int64{id}) }
|
||||
|
||||
func GetPeerVo(id int64) (vo.PeerVo, error) {
|
||||
|
||||
@@ -0,0 +1,108 @@
|
||||
package service
|
||||
|
||||
import (
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"hy2xs-admin/dao"
|
||||
"hy2xs-admin/model/dto"
|
||||
)
|
||||
|
||||
func strPtr(v string) *string { return &v }
|
||||
|
||||
// Пир установщика защищён во всех путях записи, а не только в импорте.
|
||||
//
|
||||
// Раньше проверка ReservedBootstrapPeerName стояла исключительно в
|
||||
// applyPeerImportEntry: секрет bootstrap-admin-peer продублирован в
|
||||
// /etc/hy2xs/bootstrap-admin.secret, и смена его через обычную форму панели
|
||||
// молча рассинхронизировала бы файл с базой.
|
||||
func TestUpdatePeerRefusesToResecretBootstrapPeer(t *testing.T) {
|
||||
newTestDB(t)
|
||||
id := seedPeer(t, ReservedBootstrapPeerName, ReservedBootstrapPeerName)
|
||||
|
||||
before := snapshotPeers(t)[ReservedBootstrapPeerName]
|
||||
|
||||
err := UpdatePeer(id, dto.PeerUpdateDto{Secret: strPtr("attacker-chosen-secret")})
|
||||
if err == nil {
|
||||
t.Fatal("смена секрета пира установщика не отклонена")
|
||||
}
|
||||
if !strings.Contains(err.Error(), ReservedBootstrapPeerName) {
|
||||
t.Errorf("отказ не называет пира: %v", err)
|
||||
}
|
||||
|
||||
after := snapshotPeers(t)[ReservedBootstrapPeerName]
|
||||
if after.SecretDigest == nil || before.SecretDigest == nil || *after.SecretDigest != *before.SecretDigest {
|
||||
t.Fatal("секрет пира установщика изменился несмотря на отказ")
|
||||
}
|
||||
}
|
||||
|
||||
func TestUpdatePeerRefusesToRenameBootstrapPeer(t *testing.T) {
|
||||
newTestDB(t)
|
||||
id := seedPeer(t, ReservedBootstrapPeerName, ReservedBootstrapPeerName)
|
||||
|
||||
if err := UpdatePeer(id, dto.PeerUpdateDto{Name: strPtr("renamed-peer")}); err == nil {
|
||||
t.Fatal("переименование пира установщика не отклонено")
|
||||
}
|
||||
|
||||
if _, ok := snapshotPeers(t)[ReservedBootstrapPeerName]; !ok {
|
||||
t.Fatal("пир установщика переименован несмотря на отказ")
|
||||
}
|
||||
}
|
||||
|
||||
// Зарезервированное имя нельзя занять чужому пиру. UNIQUE(name) закрывает
|
||||
// этот путь только пока bootstrap-пир существует, а его разрешено удалять.
|
||||
func TestUpdatePeerRefusesToTakeReservedName(t *testing.T) {
|
||||
newTestDB(t)
|
||||
id := seedPeer(t, "ordinary-peer", "ordinary-auth-id")
|
||||
|
||||
if err := UpdatePeer(id, dto.PeerUpdateDto{Name: strPtr(ReservedBootstrapPeerName)}); err == nil {
|
||||
t.Fatal("переименование обычного пира в зарезервированное имя не отклонено")
|
||||
}
|
||||
|
||||
peers := snapshotPeers(t)
|
||||
if _, ok := peers["ordinary-peer"]; !ok {
|
||||
t.Fatal("обычный пир переименован несмотря на отказ")
|
||||
}
|
||||
}
|
||||
|
||||
func TestCreatePeerRefusesReservedName(t *testing.T) {
|
||||
newTestDB(t)
|
||||
|
||||
name := ReservedBootstrapPeerName
|
||||
quota := int64(-1)
|
||||
if _, err := CreatePeer(dto.PeerSaveDto{Name: &name, QuotaBytes: "a}); err == nil {
|
||||
t.Fatal("создание пира с зарезервированным именем не отклонено")
|
||||
}
|
||||
}
|
||||
|
||||
// Изменения, не затрагивающие идентичность и секрет, обязаны проходить: иначе
|
||||
// оператор не смог бы ни отключить bootstrap-пира, ни ограничить ему квоту.
|
||||
func TestUpdatePeerAllowsNonIdentityChangesOnBootstrapPeer(t *testing.T) {
|
||||
newTestDB(t)
|
||||
id := seedPeer(t, ReservedBootstrapPeerName, ReservedBootstrapPeerName)
|
||||
|
||||
disabled := int64(1)
|
||||
if err := UpdatePeer(id, dto.PeerUpdateDto{Disabled: &disabled}); err != nil {
|
||||
t.Fatalf("отключение пира установщика отклонено: %v", err)
|
||||
}
|
||||
|
||||
peer := snapshotPeers(t)[ReservedBootstrapPeerName]
|
||||
if peer.Disabled == nil || *peer.Disabled != 1 {
|
||||
t.Fatal("отключение не применилось")
|
||||
}
|
||||
}
|
||||
|
||||
// Удаление разрешено намеренно: bootstrap-пир после установки — действующий
|
||||
// доступ, секрет которого лежит ещё и в файле на диске, и оператор обязан
|
||||
// иметь возможность его отозвать. Расхождения база/файл удаление не создаёт.
|
||||
func TestDeletePeerAllowsRemovingBootstrapPeer(t *testing.T) {
|
||||
newTestDB(t)
|
||||
id := seedPeer(t, ReservedBootstrapPeerName, ReservedBootstrapPeerName)
|
||||
|
||||
if err := DeletePeer(id); err != nil {
|
||||
t.Fatalf("удаление пира установщика отклонено: %v", err)
|
||||
}
|
||||
if _, err := dao.GetPeer("name = ?", ReservedBootstrapPeerName); err == nil {
|
||||
t.Fatal("пир установщика остался в базе после удаления")
|
||||
}
|
||||
}
|
||||
+17
-47
@@ -1,59 +1,29 @@
|
||||
package service
|
||||
|
||||
import (
|
||||
"encoding/base64"
|
||||
"errors"
|
||||
"strings"
|
||||
|
||||
"hy2xs-admin/dao"
|
||||
"hy2xs-admin/model/constant"
|
||||
"hy2xs-admin/model/entity"
|
||||
"hy2xs-admin/util"
|
||||
)
|
||||
|
||||
func getOrCreateConfigKey(key string, size int) (string, error) {
|
||||
cfg, err := dao.GetConfig("key = ?", key)
|
||||
if err == nil && cfg.Value != nil && strings.TrimSpace(*cfg.Value) != "" {
|
||||
return strings.TrimSpace(*cfg.Value), nil
|
||||
}
|
||||
raw, genErr := util.RandomString(size)
|
||||
if genErr != nil {
|
||||
return "", genErr
|
||||
}
|
||||
value := raw
|
||||
remark := key
|
||||
if _, saveErr := dao.SaveConfig(entity.Config{Key: &key, Value: &value, Remark: &remark}); saveErr != nil {
|
||||
if updErr := dao.UpdateConfig([]string{key}, map[string]interface{}{"value": value}); updErr != nil {
|
||||
return "", updErr
|
||||
}
|
||||
}
|
||||
return value, nil
|
||||
}
|
||||
// Криптоматериал пиров берётся из dao, а не создаётся здесь заново.
|
||||
//
|
||||
// Что было. В этом файле лежали СОБСТВЕННЫЕ getOrCreateConfigKey и
|
||||
// getPeerSecretEncryptionKey — построчные копии одноимённых функций из
|
||||
// dao/sqlite.go. Две реализации, порождающие один и тот же материал шифрования,
|
||||
// в двух пакетах: bootstrap-пир получал ключ через dao, а всё остальное — через
|
||||
// service. Пока обе читали один ключ из таблицы `config`, поведение совпадало,
|
||||
// но любое расхождение означало бы, что секреты пиров шифруются одним ключом, а
|
||||
// расшифровываются другим, и проявилось бы это на живых пирах.
|
||||
//
|
||||
// Копия в service несла ещё и порядок «сначала INSERT, при ошибке UPDATE»,
|
||||
// из-за которого каждая первая загрузка печатала в журнал
|
||||
// `duplicated key not allowed` уровня error на здоровом старте.
|
||||
|
||||
// GetPeerSecretKey — HMAC-ключ, которым считается secret_digest пира.
|
||||
func GetPeerSecretKey() (string, error) {
|
||||
return getOrCreateConfigKey(constant.PeerSecretKey, 48)
|
||||
}
|
||||
|
||||
func getPeerSecretEncryptionKey() ([]byte, error) {
|
||||
raw, err := getOrCreateConfigKey(constant.PeerSecretEncryptionKey, 32)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
decoded, decErr := util.DecodeBase64Key(raw, 32)
|
||||
if decErr == nil {
|
||||
return decoded, nil
|
||||
}
|
||||
// legacy/plain bootstrap path: convert to stable base64 once
|
||||
plain := []byte(strings.TrimSpace(raw))
|
||||
if len(plain) < 32 {
|
||||
return nil, errors.New("invalid peer secret encryption key")
|
||||
}
|
||||
plain = plain[:32]
|
||||
encoded := base64.StdEncoding.EncodeToString(plain)
|
||||
if updErr := dao.UpdateConfig([]string{constant.PeerSecretEncryptionKey}, map[string]interface{}{"value": encoded}); updErr != nil {
|
||||
return nil, updErr
|
||||
}
|
||||
return plain, nil
|
||||
return dao.GetOrCreatePeerSecretDigestKey()
|
||||
}
|
||||
|
||||
func PeerSecretDigest(rawSecret string) (string, error) {
|
||||
@@ -65,7 +35,7 @@ func PeerSecretDigest(rawSecret string) (string, error) {
|
||||
}
|
||||
|
||||
func EncryptPeerSecret(rawSecret string) (string, error) {
|
||||
key, err := getPeerSecretEncryptionKey()
|
||||
key, err := dao.GetOrCreatePeerSecretEncryptionKey()
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
@@ -76,7 +46,7 @@ func DecryptPeerSecret(stored string) (string, error) {
|
||||
if !strings.HasPrefix(stored, "v1:") {
|
||||
return stored, nil
|
||||
}
|
||||
key, err := getPeerSecretEncryptionKey()
|
||||
key, err := dao.GetOrCreatePeerSecretEncryptionKey()
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user