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

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 скриптов,
приёмка прогнана против дерева.

apps/service/journal.go

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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)
+	}
+}