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:
+25
-15
@@ -15,16 +15,22 @@ import (
|
||||
"golang.org/x/crypto/bcrypt"
|
||||
)
|
||||
|
||||
func SHA224String(password string) string {
|
||||
hash := sha256.New224()
|
||||
hash.Write([]byte(password))
|
||||
val := hash.Sum(nil)
|
||||
str := ""
|
||||
for _, v := range val {
|
||||
str += fmt.Sprintf("%02x", v)
|
||||
}
|
||||
return str
|
||||
}
|
||||
// Функции SHA224String здесь больше нет, как и ветки сравнения паролей по ней.
|
||||
//
|
||||
// Это был формат хранения паролей предыдущего поколения: несолёный SHA-224,
|
||||
// то есть быстрый хеш общего назначения, по которому словарная атака идёт
|
||||
// на порядки быстрее, чем по bcrypt, а одинаковые пароли дают одинаковые
|
||||
// хеши. VerifyPassword принимал такие хеши как «legacy» и молча переписывал
|
||||
// их в bcrypt при первом успешном входе.
|
||||
//
|
||||
// В HY2XS v1 такого хеша не может существовать. Единственные места, создающие
|
||||
// учётную запись, — ensureSecureBootstrapAdmin и `reset-admin`, и оба пишут
|
||||
// bcrypt; миграции 002/003, переносившие таблицу `account` предыдущего
|
||||
// поколения, удалены; установка возможна только на чистый хост, а конфигурация
|
||||
// 0.x отклоняется по HY2XS_CONFIG_SCHEMA_VERSION. То есть compatibility-ветка
|
||||
// пережила ровно тот слой совместимости, ради которого существовала, и
|
||||
// осталась запасным путём проверки пароля со слабым алгоритмом — в обработчике
|
||||
// логина, доступном без аутентификации.
|
||||
|
||||
func HashPassword(password string) (string, error) {
|
||||
if len(strings.TrimSpace(password)) < 6 {
|
||||
@@ -41,12 +47,16 @@ func IsBcryptHash(hash string) bool {
|
||||
return strings.HasPrefix(hash, "$2a$") || strings.HasPrefix(hash, "$2b$") || strings.HasPrefix(hash, "$2y$")
|
||||
}
|
||||
|
||||
func VerifyPassword(password string, storedHash string) (ok bool, legacy bool) {
|
||||
if IsBcryptHash(storedHash) {
|
||||
err := bcrypt.CompareHashAndPassword([]byte(storedHash), []byte(password))
|
||||
return err == nil, false
|
||||
// VerifyPassword проверяет пароль ровно против одного формата хранения.
|
||||
//
|
||||
// Хеш, который не является bcrypt, — это не «пароль в старом формате», а
|
||||
// повреждённая или подменённая строка в базе, и правильный ответ на неё —
|
||||
// отказ во входе.
|
||||
func VerifyPassword(password string, storedHash string) bool {
|
||||
if !IsBcryptHash(storedHash) {
|
||||
return false
|
||||
}
|
||||
return SHA224String(password) == storedHash, true
|
||||
return bcrypt.CompareHashAndPassword([]byte(storedHash), []byte(password)) == nil
|
||||
}
|
||||
|
||||
func HmacSHA256Hex(payload string, secret string) string {
|
||||
|
||||
@@ -1,7 +1,100 @@
|
||||
package util
|
||||
|
||||
import "testing"
|
||||
import (
|
||||
"crypto/sha256"
|
||||
"encoding/hex"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestSHA224String(t *testing.T) {
|
||||
println(SHA224String("sysadmin"))
|
||||
// Здесь был TestSHA224String, который печатал хеш в stdout и ничего не
|
||||
// проверял. Вместе с самой функцией он удалён: формат хранения паролей
|
||||
// предыдущего поколения в v1 недостижим, а тест, не содержащий утверждений,
|
||||
// создавал видимость покрытия.
|
||||
|
||||
func TestHashPasswordProducesBcrypt(t *testing.T) {
|
||||
hash, err := HashPassword("correct horse battery staple")
|
||||
if err != nil {
|
||||
t.Fatalf("HashPassword: %v", err)
|
||||
}
|
||||
if !IsBcryptHash(hash) {
|
||||
t.Fatalf("HashPassword вернул не bcrypt: %q", hash)
|
||||
}
|
||||
}
|
||||
|
||||
// Соль обязана делать два хеша одного пароля различными: именно этого не
|
||||
// давал прежний несолёный SHA-224.
|
||||
func TestHashPasswordIsSalted(t *testing.T) {
|
||||
first, err := HashPassword("one password for both")
|
||||
if err != nil {
|
||||
t.Fatalf("HashPassword: %v", err)
|
||||
}
|
||||
second, err := HashPassword("one password for both")
|
||||
if err != nil {
|
||||
t.Fatalf("HashPassword: %v", err)
|
||||
}
|
||||
if first == second {
|
||||
t.Fatal("два хеша одного пароля совпали: соль не применяется")
|
||||
}
|
||||
if !VerifyPassword("one password for both", first) || !VerifyPassword("one password for both", second) {
|
||||
t.Fatal("солёные хеши не проходят проверку")
|
||||
}
|
||||
}
|
||||
|
||||
func TestHashPasswordRejectsShortPassword(t *testing.T) {
|
||||
if _, err := HashPassword("12345"); err == nil {
|
||||
t.Fatal("слишком короткий пароль принят")
|
||||
}
|
||||
if _, err := HashPassword(" "); err == nil {
|
||||
t.Fatal("пароль из пробелов принят")
|
||||
}
|
||||
}
|
||||
|
||||
func TestVerifyPasswordAcceptsOnlyCorrectPassword(t *testing.T) {
|
||||
hash, err := HashPassword("s3cret-passphrase")
|
||||
if err != nil {
|
||||
t.Fatalf("HashPassword: %v", err)
|
||||
}
|
||||
if !VerifyPassword("s3cret-passphrase", hash) {
|
||||
t.Error("верный пароль отклонён")
|
||||
}
|
||||
if VerifyPassword("s3cret-passphras", hash) {
|
||||
t.Error("неверный пароль принят")
|
||||
}
|
||||
if VerifyPassword("", hash) {
|
||||
t.Error("пустой пароль принят")
|
||||
}
|
||||
}
|
||||
|
||||
// Главная регрессия: несолёный SHA-224 из предыдущего поколения больше не
|
||||
// является допустимым форматом хранения. Раньше VerifyPassword сравнивал с ним
|
||||
// напрямую и возвращал признак legacy, то есть вход по такому хешу удавался.
|
||||
func TestVerifyPasswordRejectsLegacySha224Hash(t *testing.T) {
|
||||
password := "sysadmin"
|
||||
|
||||
sum := sha256.Sum224([]byte(password))
|
||||
legacyHash := hex.EncodeToString(sum[:])
|
||||
|
||||
if VerifyPassword(password, legacyHash) {
|
||||
t.Fatal("вход по несолёному SHA-224 всё ещё возможен")
|
||||
}
|
||||
if IsBcryptHash(legacyHash) {
|
||||
t.Fatal("SHA-224 опознан как bcrypt")
|
||||
}
|
||||
}
|
||||
|
||||
// Любая строка, не являющаяся bcrypt-хешем, — повреждённое или подменённое
|
||||
// значение в базе, а не «другой формат».
|
||||
func TestVerifyPasswordRejectsNonBcryptStorage(t *testing.T) {
|
||||
for _, stored := range []string{
|
||||
"",
|
||||
"plaintext-password",
|
||||
"$1$abcdefgh$0123456789abcdef",
|
||||
"$argon2id$v=19$m=65536,t=3,p=4$c29tZXNhbHQ$hash",
|
||||
strings.Repeat("a", 60),
|
||||
} {
|
||||
if VerifyPassword("plaintext-password", stored) {
|
||||
t.Errorf("принят пароль против не-bcrypt значения %q", stored)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+44
-8
@@ -1,19 +1,55 @@
|
||||
package util
|
||||
|
||||
import "crypto/rand"
|
||||
import (
|
||||
"crypto/rand"
|
||||
"errors"
|
||||
)
|
||||
|
||||
const charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
|
||||
|
||||
// rejectionThreshold — граница равномерности при отображении байта в алфавит.
|
||||
//
|
||||
// В алфавите 62 символа, а байт принимает 256 значений. 256 = 4×62 + 8,
|
||||
// поэтому при прямом `charset[b % 62]` первые ВОСЕМЬ символов алфавита
|
||||
// («a»…«h») выпадают пятью значениями байта, а остальные 54 — четырьмя. То
|
||||
// есть распределение смещено примерно на четверть в пользу начала алфавита.
|
||||
//
|
||||
// Байты со значением 248 и выше отбрасываются: оставшиеся 248 = 4×62 делятся
|
||||
// на длину алфавита нацело, и остаток становится равномерным. Цена — около 3%
|
||||
// отброшенных байтов, то есть один лишний вызов rand.Read на несколько сотен
|
||||
// символов.
|
||||
//
|
||||
// Практическая потеря энтропии у прежнего варианта была невелика, но это
|
||||
// ЕДИНСТВЕННЫЙ генератор секретов продукта: через него проходят JWT_SECRET,
|
||||
// PEER_SECRET_KEY, PEER_SECRET_ENCRYPTION_KEY, секрет trafficStats API,
|
||||
// секреты и auth_id пиров. Смещённое распределение в такой позиции чинится
|
||||
// пятью строками и не обсуждается на каждом аудите заново.
|
||||
const rejectionThreshold = 256 - (256 % len(charset))
|
||||
|
||||
// RandomString возвращает строку заданной длины из букв и цифр, равномерно
|
||||
// распределённых по алфавиту.
|
||||
func RandomString(length int) (string, error) {
|
||||
bytes := make([]byte, length)
|
||||
_, err := rand.Read(bytes)
|
||||
if err != nil {
|
||||
return "", err
|
||||
if length <= 0 {
|
||||
return "", errors.New("random string length must be positive")
|
||||
}
|
||||
|
||||
for i := range bytes {
|
||||
bytes[i] = charset[int(bytes[i])%len(charset)]
|
||||
out := make([]byte, 0, length)
|
||||
buf := make([]byte, length)
|
||||
|
||||
for len(out) < length {
|
||||
if _, err := rand.Read(buf); err != nil {
|
||||
return "", err
|
||||
}
|
||||
for _, b := range buf {
|
||||
if int(b) >= rejectionThreshold {
|
||||
continue
|
||||
}
|
||||
out = append(out, charset[int(b)%len(charset)])
|
||||
if len(out) == length {
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return string(bytes), nil
|
||||
return string(out), nil
|
||||
}
|
||||
|
||||
@@ -0,0 +1,93 @@
|
||||
package util
|
||||
|
||||
import (
|
||||
"math"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestRandomStringLengthAndAlphabet(t *testing.T) {
|
||||
for _, length := range []int{1, 6, 18, 24, 32, 48, 64, 300} {
|
||||
value, err := RandomString(length)
|
||||
if err != nil {
|
||||
t.Fatalf("RandomString(%d): %v", length, err)
|
||||
}
|
||||
if len(value) != length {
|
||||
t.Errorf("RandomString(%d) вернул строку длины %d", length, len(value))
|
||||
}
|
||||
for _, r := range value {
|
||||
if !strings.ContainsRune(charset, r) {
|
||||
t.Errorf("RandomString(%d) вернул символ %q вне алфавита", length, r)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestRandomStringRejectsNonPositiveLength(t *testing.T) {
|
||||
for _, length := range []int{0, -1} {
|
||||
if _, err := RandomString(length); err == nil {
|
||||
t.Errorf("RandomString(%d) не отклонён", length)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Проверка отсутствия modulo bias.
|
||||
//
|
||||
// Прежняя реализация делала charset[b % 62] по байту напрямую. 256 = 4×62 + 8,
|
||||
// поэтому первые восемь символов алфавита выпадали пятью значениями байта из
|
||||
// 256, а остальные 54 — четырьмя: перекос примерно на 25%.
|
||||
//
|
||||
// Тест сравнивает наблюдаемые частоты первых восьми символов алфавита с
|
||||
// остальными. На выборке в 200 000 символов ожидаемая частота каждого — около
|
||||
// 3226; перекос в 25% дал бы у «a»…«h» примерно 4032 против 3226, то есть
|
||||
// разницу в сотни раз больше статистического шума. Порог взят с большим
|
||||
// запасом, чтобы тест не был флаки: он ловит систематическое смещение, а не
|
||||
// проверяет качество генератора случайных чисел.
|
||||
func TestRandomStringHasNoModuloBias(t *testing.T) {
|
||||
const sampleSize = 200000
|
||||
|
||||
value, err := RandomString(sampleSize)
|
||||
if err != nil {
|
||||
t.Fatalf("RandomString: %v", err)
|
||||
}
|
||||
|
||||
counts := make(map[rune]int, len(charset))
|
||||
for _, r := range value {
|
||||
counts[r]++
|
||||
}
|
||||
|
||||
expected := float64(sampleSize) / float64(len(charset))
|
||||
|
||||
// Восемь символов, которые смещённая реализация выдавала чаще остальных.
|
||||
biasedPrefix := charset[:256%len(charset)]
|
||||
|
||||
var prefixTotal, restTotal float64
|
||||
for _, r := range charset {
|
||||
if strings.ContainsRune(biasedPrefix, r) {
|
||||
prefixTotal += float64(counts[r])
|
||||
} else {
|
||||
restTotal += float64(counts[r])
|
||||
}
|
||||
}
|
||||
|
||||
prefixMean := prefixTotal / float64(len(biasedPrefix))
|
||||
restMean := restTotal / float64(len(charset)-len(biasedPrefix))
|
||||
|
||||
// Смещённая реализация давала prefixMean/restMean = 5/4 = 1.25.
|
||||
// Допуск 5% оставляет между порогом и дефектом кратный зазор.
|
||||
ratio := prefixMean / restMean
|
||||
if math.Abs(ratio-1) > 0.05 {
|
||||
t.Errorf(
|
||||
"распределение смещено: начало алфавита %.1f, остальные %.1f, отношение %.4f",
|
||||
prefixMean, restMean, ratio,
|
||||
)
|
||||
}
|
||||
|
||||
// Ни один символ алфавита не должен пропасть или доминировать.
|
||||
for _, r := range charset {
|
||||
count := float64(counts[r])
|
||||
if math.Abs(count-expected)/expected > 0.15 {
|
||||
t.Errorf("символ %q встретился %d раз при ожидаемых %.0f", r, counts[r], expected)
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user