接入独立 DNS 账户管理接口并记录三库竞态复核

This commit is contained in:
xuans committed 2026-10-04 05:11:37 +08:00
1 parent 02e039984a
commit 1dc72f2b44
14 files changed
+720 -10

No files matched your search

@@ -0,0 +1,259 @@
package httpapi
import (
"context"
"errors"
"net/http"
"strings"
"time"
"github.com/gin-gonic/gin"
"git.pcux.cn/xuans/Scert/backend/internal/dnsprovider"
"git.pcux.cn/xuans/Scert/backend/internal/dnsverification"
"git.pcux.cn/xuans/Scert/backend/internal/domain"
"git.pcux.cn/xuans/Scert/backend/internal/repository"
)
type dnsAccountVerifier interface {
Verify(context.Context, string, string, map[string]string) (dnsverification.Report, error)
}
func (s *Server) managedDNSRepository(c *gin.Context) (repository.DNSAccountRepository, bool) {
repo, ok := s.projectMembers.(repository.DNSAccountRepository)
if !ok {
s.writeError(c, http.StatusServiceUnavailable, "DNS 账户服务尚未就绪", nil)
}
return repo, ok
}
func (s *Server) writeDNSAccountError(c *gin.Context, err error) {
switch {
case errors.Is(err, repository.ErrProjectAccessDenied):
s.writeError(c, http.StatusForbidden, "无权操作此 DNS 账户", nil)
case errors.Is(err, repository.ErrDNSAccountConflict):
s.writeError(c, http.StatusConflict, "DNS 账户已变更,请刷新后重试", nil)
default:
// 驱动、秘密仓库和服务商的错误均可能携带凭据,不能回显或写入日志。
s.writeError(c, http.StatusServiceUnavailable, "DNS 账户操作失败,请稍后重试", nil)
}
}
func (s *Server) createManagedDNSAccount(c *gin.Context) {
repo, ok := s.managedDNSRepository(c)
if !ok {
return
}
var request struct {
Name string `json:"name"`
ProjectID string `json:"project_id"`
Provider string `json:"provider"`
Credentials map[string]string `json:"credentials"`
}
if err := bindJSON(c, &request, setupRequestLimit); err != nil {
s.writeError(c, http.StatusBadRequest, "DNS 账户参数无效", nil)
return
}
if !s.authorizeProjectPermissions(c, request.ProjectID, domain.PermissionDNSManage) {
return
}
item := domain.DNSAccount{
ID: domain.NewID(), Name: strings.TrimSpace(request.Name), ProjectID: request.ProjectID,
OwnerUserID: c.GetString(authenticatedActorKey), Provider: request.Provider,
CredentialRef: "secret://dns/" + domain.NewID(), Status: domain.DNSAccountActive,
VerificationState: domain.DNSAccountUnverified, Revision: 1,
}
if err := item.Validate(); err != nil {
s.writeError(c, http.StatusBadRequest, "DNS 账户名称、项目或服务商无效", nil)
return
}
if !s.storeManagedDNSCredential(c, item.Provider, item.CredentialRef, request.Credentials) {
return
}
created, err := repo.CreateDNSAccount(c.Request.Context(), item.OwnerUserID, item)
if err != nil {
// 提交错误可能有歧义,不能猜测未提交并删除新秘密;后续引用回收统一处理。
s.writeDNSAccountError(c, err)
return
}
c.JSON(http.StatusCreated, created)
}
func (s *Server) storeManagedDNSCredential(c *gin.Context, provider, reference string, credentials map[string]string) bool {
descriptor, err := dnsprovider.GetDescriptor(provider)
if err != nil || !descriptor.Available {
s.writeError(c, http.StatusBadRequest, "DNS 服务商不可用", nil)
return false
}
cleaned, err := dnsprovider.ValidateCredentials(provider, credentials)
if err != nil {
s.writeError(c, http.StatusBadRequest, "DNS 凭据字段无效或不完整", nil)
return false
}
if s.secrets == nil {
s.writeError(c, http.StatusServiceUnavailable, "凭据存储尚未就绪", nil)
return false
}
if err := s.secrets.Put(c.Request.Context(), reference, cleaned); err != nil {
s.writeError(c, http.StatusServiceUnavailable, "保存 DNS 凭据失败", nil)
return false
}
return true
}
func (s *Server) getManagedDNSAccount(c *gin.Context) {
repo, ok := s.managedDNSRepository(c)
if !ok {
return
}
item, err := repo.GetVisibleDNSAccount(c.Request.Context(), c.GetString(authenticatedActorKey), c.Param("id"))
if err != nil {
s.writeDNSAccountError(c, err)
return
}
c.JSON(http.StatusOK, item)
}
func (s *Server) renameManagedDNSAccount(c *gin.Context) {
repo, ok := s.managedDNSRepository(c)
if !ok {
return
}
var request struct {
Name string `json:"name"`
Revision int64 `json:"revision"`
}
if err := bindJSON(c, &request, setupRequestLimit); err != nil || request.Revision < 1 {
s.writeError(c, http.StatusBadRequest, "DNS 账户名称或版本无效", nil)
return
}
// 先核对可见范围,避免借参数错误探测其他项目账户。
item, err := repo.GetVisibleDNSAccount(c.Request.Context(), c.GetString(authenticatedActorKey), c.Param("id"))
if err != nil {
s.writeDNSAccountError(c, err)
return
}
item.Name, item.CredentialRef = strings.TrimSpace(request.Name), "secret://dns/validation"
if err := item.Validate(); err != nil {
s.writeError(c, http.StatusBadRequest, "DNS 账户名称无效", nil)
return
}
updated, err := repo.RenameDNSAccount(c.Request.Context(), c.GetString(authenticatedActorKey), c.Param("id"), request.Revision, item.Name)
if err != nil {
s.writeDNSAccountError(c, err)
return
}
c.JSON(http.StatusOK, updated)
}
func (s *Server) setManagedDNSAccountStatus(c *gin.Context) {
repo, ok := s.managedDNSRepository(c)
if !ok {
return
}
var request struct {
Enabled *bool `json:"enabled"`
Revision int64 `json:"revision"`
}
if err := bindJSON(c, &request, setupRequestLimit); err != nil || request.Enabled == nil || request.Revision < 1 {
s.writeError(c, http.StatusBadRequest, "DNS 账户状态或版本无效", nil)
return
}
item, err := repo.SetDNSAccountEnabled(c.Request.Context(), c.GetString(authenticatedActorKey), c.Param("id"), request.Revision, *request.Enabled)
if err != nil {
s.writeDNSAccountError(c, err)
return
}
c.JSON(http.StatusOK, item)
}
func (s *Server) rotateManagedDNSAccountCredential(c *gin.Context) {
repo, ok := s.managedDNSRepository(c)
if !ok {
return
}
var request struct {
Revision int64 `json:"revision"`
Credentials map[string]string `json:"credentials"`
}
if err := bindJSON(c, &request, setupRequestLimit); err != nil || request.Revision < 1 {
s.writeError(c, http.StatusBadRequest, "DNS 凭据或版本无效", nil)
return
}
item, err := repo.GetVisibleDNSAccount(c.Request.Context(), c.GetString(authenticatedActorKey), c.Param("id"))
if err != nil {
s.writeDNSAccountError(c, err)
return
}
if !s.authorizeProjectPermissions(c, item.ProjectID, domain.PermissionDNSManage) {
return
}
if item.Revision != request.Revision {
s.writeDNSAccountError(c, repository.ErrDNSAccountConflict)
return
}
reference := "secret://dns/" + domain.NewID()
if !s.storeManagedDNSCredential(c, item.Provider, reference, request.Credentials) {
return
}
item, err = repo.RotateDNSAccountCredential(c.Request.Context(), c.GetString(authenticatedActorKey), item.ID, request.Revision, reference)
if err != nil {
s.writeDNSAccountError(c, err)
return
}
// 不删除旧凭据,仍有运行任务或旧配置引用时须由后续租约回收流程处理。
c.JSON(http.StatusOK, item)
}
func (s *Server) verifyManagedDNSAccount(c *gin.Context) {
repo, ok := s.managedDNSRepository(c)
if !ok {
return
}
var request struct {
Revision int64 `json:"revision"`
TestDomain string `json:"test_domain"`
}
if err := bindJSON(c, &request, setupRequestLimit); err != nil || request.Revision < 1 || !domain.IsValidName(request.TestDomain) {
s.writeError(c, http.StatusBadRequest, "DNS 验证域名或版本无效", nil)
return
}
actor := c.GetString(authenticatedActorKey)
item, err := repo.GetDNSAccountForVerification(c.Request.Context(), actor, c.Param("id"))
if err != nil {
s.writeDNSAccountError(c, err)
return
}
if item.Revision != request.Revision {
s.writeDNSAccountError(c, repository.ErrDNSAccountConflict)
return
}
credentials, err := s.readDNSCredentials(c.Request.Context(), item.CredentialRef)
if err != nil {
s.writeError(c, http.StatusServiceUnavailable, "读取 DNS 凭据失败", nil)
return
}
verifier := s.dnsAccountVerifier
if verifier == nil {
verifier = dnsprovider.NewTester(dnsprovider.NewLegoFactory())
}
ctx, cancel := context.WithTimeout(c.Request.Context(), dnsprovider.PermissionVerificationTimeoutFor(item.Provider))
defer cancel()
_, verificationErr := verifier.Verify(ctx, item.Provider, request.TestDomain, credentials)
if verificationErr == nil {
verificationErr = ctx.Err()
}
// 在线调用可能超时或断连,短独立上下文只用于记录实际结果,仍重新核对权限与版本。
recordCtx, recordCancel := context.WithTimeout(context.WithoutCancel(c.Request.Context()), 5*time.Second)
defer recordCancel()
updated, err := repo.RecordDNSAccountVerification(recordCtx, actor, item.ID, item.Revision, verificationErr == nil)
if err != nil {
s.writeDNSAccountError(c, err)
return
}
if verificationErr != nil {
c.JSON(http.StatusUnprocessableEntity, gin.H{"error": "DNS 在线验证失败,请检查凭据、测试域名和权限", "account": updated})
return
}
c.JSON(http.StatusOK, gin.H{"verified": true, "account": updated})
}
@@ -0,0 +1,295 @@
package httpapi
import (
"context"
"encoding/json"
"errors"
"net/http"
"net/http/httptest"
"strings"
"testing"
"git.pcux.cn/xuans/Scert/backend/internal/dnsverification"
"git.pcux.cn/xuans/Scert/backend/internal/domain"
)
type accountVerifierFunc func(context.Context, string, string, map[string]string) (dnsverification.Report, error)
func (f accountVerifierFunc) Verify(ctx context.Context, provider, name string, credentials map[string]string) (dnsverification.Report, error) {
return f(ctx, provider, name, credentials)
}
const managedDNSCreateBody = `{"name":"项目 DNS","project_id":"project-a","provider":"cloudflare","credentials":{"api_token":"fixture-sensitive-token"}}`
func managedDNSRequest(t *testing.T, f projectMemberAPIFixture, actor, method, path, body string, status int) *httptest.ResponseRecorder {
t.Helper()
response := serveUserRequest(f.server, f.cookies[actor], method, "/api/v1/dns/accounts"+path, body)
if response.Code != status {
t.Fatalf("DNS 请求状态错误:%s %s %s,实际 %d 期望 %d,%s", actor, method, path, response.Code, status, response.Body.String())
}
if response.Header().Get("Cache-Control") != "private, no-store" || response.Header().Get("Vary") != "Cookie" {
t.Fatal("DNS 账户响应未隔离缓存")
}
for _, value := range []string{"fixture-sensitive-token", "rotated-sensitive-token", "secret://", "credential_ref", "internal-sensitive-error"} {
if strings.Contains(response.Body.String(), value) {
t.Fatalf("DNS 账户响应暴露内部敏感内容:%s", value)
}
}
return response
}
func newManagedDNSFixture(t *testing.T) (projectMemberAPIFixture, *fakeSecretReaderStore, domain.DNSAccount) {
t.Helper()
f := newProjectMemberAPIFixture(t)
f.server.config.DNS.CredentialRef = ""
secrets := &fakeSecretReaderStore{}
f.server.secrets = secrets
response := managedDNSRequest(t, f, "manager", http.MethodPost, "", managedDNSCreateBody, http.StatusCreated)
var item domain.DNSAccount
if err := json.Unmarshal(response.Body.Bytes(), &item); err != nil || item.ID == "" || item.OwnerUserID != "manager" || item.VerificationState != domain.DNSAccountUnverified || item.Revision != 1 {
t.Fatal("创建未固定真实归属和验证状态", err)
}
return f, secrets, item
}
func TestManagedDNSAccountLifecycle(t *testing.T) {
f, secrets, item := newManagedDNSFixture(t)
path := "/" + item.ID
verifications := 0
f.server.dnsAccountVerifier = accountVerifierFunc(func(ctx context.Context, provider, name string, credentials map[string]string) (dnsverification.Report, error) {
verifications++
if provider != "cloudflare" || name != "example.test" || credentials["api_token"] != "fixture-sensitive-token" {
t.Fatal("验证未使用数据库账户对应的凭据")
}
if _, exists := ctx.Deadline(); !exists {
t.Fatal("在线验证没有超时上限")
}
return dnsverification.Report{}, nil
})
managedDNSRequest(t, f, "manager", http.MethodPost, path+"/verify", `{"revision":1,"test_domain":"example.test"}`, http.StatusOK)
stored, err := f.members.GetDNSAccountForUse(t.Context(), "manager", item.ID, "project-a")
if err != nil || stored.Revision != 2 || stored.CredentialRef == "" || verifications != 1 {
t.Fatal("验证结果未写入正确版本", err)
}
oldReference := stored.CredentialRef
managedDNSRequest(t, f, "manager", http.MethodPut, path, `{"revision":2,"name":"更名后的账户"}`, http.StatusOK)
managedDNSRequest(t, f, "manager", http.MethodPut, path, `{"revision":2,"name":"旧版本"}`, http.StatusConflict)
managedDNSRequest(t, f, "manager", http.MethodPut, path+"/status", `{"revision":3,"enabled":false}`, http.StatusOK)
managedDNSRequest(t, f, "manager", http.MethodPost, path+"/verify", `{"revision":4,"test_domain":"example.test"}`, http.StatusForbidden)
if verifications != 1 {
t.Fatal("已禁用账户仍调用服务商")
}
managedDNSRequest(t, f, "manager", http.MethodPut, path+"/credentials", `{"revision":4,"credentials":{"api_token":"rotated-sensitive-token"}}`, http.StatusOK)
managedDNSRequest(t, f, "manager", http.MethodPut, path+"/status", `{"revision":5,"enabled":true}`, http.StatusOK)
stored, err = f.members.GetDNSAccountForVerification(t.Context(), "manager", item.ID)
if err != nil || stored.CredentialRef == oldReference || stored.VerificationState != domain.DNSAccountUnverified || len(secrets.data) != 2 {
t.Fatal("轮换没有生成新引用、保留旧引用或清除验证状态", err)
}
f.server.dnsAccountVerifier = accountVerifierFunc(func(_ context.Context, _, _ string, credentials map[string]string) (dnsverification.Report, error) {
if credentials["api_token"] != "rotated-sensitive-token" {
t.Fatal("验证仍使用旧凭据")
}
return dnsverification.Report{}, errors.New("internal-sensitive-error")
})
managedDNSRequest(t, f, "manager", http.MethodPost, path+"/verify", `{"revision":6,"test_domain":"example.test"}`, http.StatusUnprocessableEntity)
stored, err = f.members.GetVisibleDNSAccount(t.Context(), "manager", item.ID)
if err != nil || stored.VerificationState != domain.DNSAccountVerificationFailed || stored.Revision != 7 {
t.Fatal("服务商失败没有记录到对应版本", err)
}
var count int
if err := f.db.QueryRow(`SELECT COUNT(*) FROM audit_logs WHERE resource_type='dns_account' AND (message LIKE '%token%' OR message LIKE '%secret://%')`).Scan(&count); err != nil || count != 0 {
t.Fatal("审计泄露凭据", err)
}
}
func TestManagedDNSAccountPermissionsAndListing(t *testing.T) {
f, secrets, item := newManagedDNSFixture(t)
for _, actor := range []string{"viewer", "global-admin", "target", "anonymous"} {
status := http.StatusForbidden
if actor == "anonymous" {
status = http.StatusUnauthorized
}
managedDNSRequest(t, f, actor, http.MethodPost, "", managedDNSCreateBody, status)
managedDNSRequest(t, f, actor, http.MethodPut, "/"+item.ID, `{"revision":1,"name":"越权更名"}`, status)
managedDNSRequest(t, f, actor, http.MethodPut, "/"+item.ID+"/status", `{"revision":1,"enabled":false}`, status)
managedDNSRequest(t, f, actor, http.MethodPut, "/"+item.ID+"/credentials", `{"revision":1,"credentials":{"api_token":"rotated-sensitive-token"}}`, status)
managedDNSRequest(t, f, actor, http.MethodPost, "/"+item.ID+"/verify", `{"revision":1,"test_domain":"example.test"}`, status)
}
if len(secrets.data) != 1 || secrets.getCalls != 0 {
t.Fatal("越权请求访问了秘密存储")
}
for actor, count := range map[string]int{"manager": 1, "viewer": 1, "global-admin": 0, "target": 0, "primary-super-admin": 1} {
response := managedDNSRequest(t, f, actor, http.MethodGet, "", "", http.StatusOK)
var page struct {
Items []dnsAccountView `json:"items"`
}
if err := json.Unmarshal(response.Body.Bytes(), &page); err != nil || len(page.Items) != count {
t.Fatal("独立账户列表未按项目过滤", actor, err)
}
if count == 1 && (page.Items[0].OwnerUserID != "manager" || page.Items[0].OwnerState != "assigned" || page.Items[0].OwnerUsername == "" || !page.Items[0].Managed) {
t.Fatal("列表缺少用户归属或管理标记")
}
}
managedDNSRequest(t, f, "viewer", http.MethodGet, "/"+item.ID, "", http.StatusOK)
managedDNSRequest(t, f, "global-admin", http.MethodGet, "/"+item.ID, "", http.StatusForbidden)
managedDNSRequest(t, f, "global-admin", http.MethodGet, "/missing", "", http.StatusForbidden)
// 系统账户属于别的项目时,不能把本项目独立账户一并隐藏。
f.server.config.DNS.CredentialRef, f.server.config.DNS.ProjectID = "secret://legacy/hidden", "project-b"
response := managedDNSRequest(t, f, "manager", http.MethodGet, "", "", http.StatusOK)
if !strings.Contains(response.Body.String(), item.ID) || strings.Contains(response.Body.String(), "system-dns") || secrets.getCalls != 0 {
t.Fatal("旧系统账户影响独立账户范围或触发秘密读取")
}
if err := f.members.RevokeProjectRole(t.Context(), "primary-super-admin", "project-a", "manager", domain.ProjectRoleAdmin); err != nil {
t.Fatal(err)
}
if _, err := f.db.Exec(`DELETE FROM users WHERE id='manager'`); err != nil {
t.Fatal(err)
}
f.server.config.DNS.CredentialRef = ""
response = managedDNSRequest(t, f, "primary-super-admin", http.MethodGet, "", "", http.StatusOK)
if !strings.Contains(response.Body.String(), `"owner_state":"missing"`) {
t.Fatal("删除用户后未保留历史归属")
}
}
func TestManagedDNSAccountRejectsForgedAndStaleVerification(t *testing.T) {
for _, change := range []string{"rotate", "disable", "revoke"} {
t.Run(change, func(t *testing.T) {
f, secrets, item := newManagedDNSFixture(t)
f.server.dnsAccountVerifier = accountVerifierFunc(func(context.Context, string, string, map[string]string) (dnsverification.Report, error) {
var err error
switch change {
case "rotate":
_, err = f.members.RotateDNSAccountCredential(t.Context(), "manager", item.ID, 1, "secret://dns/new-version")
case "disable":
_, err = f.members.SetDNSAccountEnabled(t.Context(), "manager", item.ID, 1, false)
case "revoke":
err = f.members.RevokeProjectRole(t.Context(), "primary-super-admin", "project-a", "manager", domain.ProjectRoleAdmin)
}
if err != nil {
t.Fatal(err)
}
return dnsverification.Report{}, nil
})
path := "/" + item.ID + "/verify"
managedDNSRequest(t, f, "manager", http.MethodPost, path, `{"revision":1,"test_domain":"example.test","verified":true}`, http.StatusBadRequest)
managedDNSRequest(t, f, "manager", http.MethodPost, path, `{"revision":2,"test_domain":"example.test"}`, http.StatusConflict)
if secrets.getCalls != 0 {
t.Fatal("伪造或过期请求读取凭据")
}
status := http.StatusConflict
if change == "revoke" {
status = http.StatusForbidden
}
managedDNSRequest(t, f, "manager", http.MethodPost, path, `{"revision":1,"test_domain":"example.test"}`, status)
stored, err := f.members.GetVisibleDNSAccount(t.Context(), "primary-super-admin", item.ID)
if err != nil || stored.VerificationState != domain.DNSAccountUnverified {
t.Fatal("旧验证响应覆盖新状态", err)
}
})
}
}
func TestManagedDNSAccountStrictRequests(t *testing.T) {
f, secrets, item := newManagedDNSFixture(t)
for _, field := range []string{`"owner_user_id":"primary-super-admin"`, `"credential_ref":"secret://dns/forged"`, `"verification_state":"verified"`, `"status":"active"`} {
body := strings.TrimSuffix(managedDNSCreateBody, "}") + "," + field + "}"
managedDNSRequest(t, f, "manager", http.MethodPost, "", body, http.StatusBadRequest)
}
for _, body := range []string{`{"revision":1}`, `{"revision":0,"enabled":true}`, `{"revision":1,"enabled":false,"actor_id":"primary-super-admin"}`} {
managedDNSRequest(t, f, "manager", http.MethodPut, "/"+item.ID+"/status", body, http.StatusBadRequest)
}
managedDNSRequest(t, f, "manager", http.MethodPost, "", strings.Replace(managedDNSCreateBody, "project-a", "project-b", 1), http.StatusForbidden)
managedDNSRequest(t, f, "manager", http.MethodPost, "", strings.Replace(managedDNSCreateBody, "cloudflare", "unknown", 1), http.StatusBadRequest)
managedDNSRequest(t, f, "manager", http.MethodPut, "/"+item.ID, `{"revision":1,"name":""}`, http.StatusBadRequest)
managedDNSRequest(t, f, "manager", http.MethodPut, "/"+item.ID+"/credentials", `{"revision":1,"credentials":{"api_token":""}}`, http.StatusBadRequest)
if len(secrets.data) != 1 {
t.Fatal("无效请求留下秘密")
}
request := httptest.NewRequest(http.MethodPost, "/api/v1/dns/accounts", strings.NewReader(managedDNSCreateBody))
request.Header.Set("Origin", "https://untrusted.example.test")
request.AddCookie(f.cookies["manager"])
response := httptest.NewRecorder()
f.server.Handler().ServeHTTP(response, request)
if response.Code != http.StatusForbidden || len(secrets.data) != 1 {
t.Fatal("跨源请求创建了账户", response.Code)
}
if _, err := f.db.Exec(`CREATE TRIGGER reject_managed_dns_audit BEFORE INSERT ON audit_logs WHEN NEW.resource_type='dns_account' BEGIN SELECT RAISE(ABORT, 'blocked'); END`); err != nil {
t.Fatal(err)
}
managedDNSRequest(t, f, "manager", http.MethodPut, "/"+item.ID, `{"revision":1,"name":"不能保存"}`, http.StatusServiceUnavailable)
managedDNSRequest(t, f, "manager", http.MethodPost, "", managedDNSCreateBody, http.StatusServiceUnavailable)
var count int
if err := f.db.QueryRow(`SELECT COUNT(*) FROM dns_accounts`).Scan(&count); err != nil || count != 1 {
t.Fatal("审计失败留下账户", err)
}
stored, err := f.members.GetVisibleDNSAccount(t.Context(), "manager", item.ID)
if err != nil || stored.Name != item.Name || stored.Revision != item.Revision {
t.Fatal("审计失败没有回滚改名", err)
}
// 不确定提交结果时保留新秘密,避免误删可能已提交的引用;待引用回收流程处理。
if len(secrets.data) != 2 {
t.Fatalf("提交错误后的秘密保护不符:%d", len(secrets.data))
}
}
type failingDNSAccountSecretStore struct {
*fakeSecretReaderStore
putErr error
getErr error
}
func (s failingDNSAccountSecretStore) Put(ctx context.Context, reference string, credentials map[string]string) error {
if s.putErr != nil {
return s.putErr
}
return s.fakeSecretReaderStore.Put(ctx, reference, credentials)
}
func (s failingDNSAccountSecretStore) Get(ctx context.Context, reference string) (map[string]string, error) {
if s.getErr != nil {
return nil, s.getErr
}
return s.fakeSecretReaderStore.Get(ctx, reference)
}
func TestManagedDNSAccountDependencyFailures(t *testing.T) {
for _, failure := range []string{"missing_store", "write_store", "read_store", "repository", "canceled_verification"} {
t.Run(failure, func(t *testing.T) {
f, secrets, item := newManagedDNSFixture(t)
method, path, body := http.MethodPost, "", managedDNSCreateBody
status := http.StatusServiceUnavailable
calls := 0
f.server.dnsAccountVerifier = accountVerifierFunc(func(context.Context, string, string, map[string]string) (dnsverification.Report, error) {
calls++
return dnsverification.Report{}, context.Canceled
})
switch failure {
case "missing_store":
f.server.secrets = nil
case "write_store":
f.server.secrets = failingDNSAccountSecretStore{fakeSecretReaderStore: secrets, putErr: errors.New("internal-sensitive-error")}
case "read_store":
f.server.secrets = failingDNSAccountSecretStore{fakeSecretReaderStore: secrets, getErr: errors.New("internal-sensitive-error")}
path, body = "/"+item.ID+"/verify", `{"revision":1,"test_domain":"example.test"}`
case "repository":
f.server.projectMembers = nil
case "canceled_verification":
path, body = "/"+item.ID+"/verify", `{"revision":1,"test_domain":"example.test"}`
status = http.StatusUnprocessableEntity
}
managedDNSRequest(t, f, "manager", method, path, body, status)
stored, err := f.members.GetVisibleDNSAccount(t.Context(), "primary-super-admin", item.ID)
if err != nil {
t.Fatal(err)
}
if failure == "canceled_verification" {
if calls != 1 || stored.VerificationState != domain.DNSAccountVerificationFailed || stored.Revision != 2 {
t.Fatal("取消验证没有记录失败")
}
} else if calls != 0 || stored.Revision != 1 || len(secrets.data) != 1 {
t.Fatal("依赖失败仍调用服务商或修改状态")
}
})
}
}
+44 -1
View File
@@ -25,14 +25,32 @@ type dnsAccountView struct {
OwnerState string `json:"owner_state"`
VerificationState string `json:"verification_state"`
CredentialState string `json:"credential_state"`
Status string `json:"status"`
Revision int64 `json:"revision"`
Managed bool `json:"managed"`
}
// listDNSAccounts 仅列出当前绑定的配置,不枚举凭据仓库中的临时或历史密钥。
// listDNSAccounts 合并独立账户和旧系统配置;不枚举秘密仓库中的临时或历史密钥。
func (s *Server) listDNSAccounts(c *gin.Context) {
s.configMu.RLock()
cfg := s.config
s.configMu.RUnlock()
items := make([]dnsAccountView, 0, 1)
if repo, ok := s.projectMembers.(repository.DNSAccountRepository); ok {
accounts, err := repo.ListVisibleDNSAccounts(c.Request.Context(), c.GetString(authenticatedActorKey))
if err != nil {
s.writeDNSAccountError(c, err)
return
}
for _, account := range accounts {
item, err := s.managedDNSAccountView(c, account)
if err != nil {
s.writeError(c, http.StatusServiceUnavailable, "读取 DNS 账户归属失败", nil)
return
}
items = append(items, item)
}
}
if strings.TrimSpace(cfg.DNS.CredentialRef) == "" {
c.JSON(http.StatusOK, gin.H{"items": items})
return
@@ -66,6 +84,7 @@ func (s *Server) listDNSAccounts(c *gin.Context) {
ProviderName: "未知服务商", AccountIdentifier: "未提供账号标识",
OwnerUserID: cfg.DNS.OwnerUserID, OwnerState: "unassigned", OwnerUsername: "未分配",
VerificationState: cfg.DNS.VerificationState, CredentialState: "available",
Status: domain.DNSAccountActive,
}
var owner repository.User
ownerID := strings.TrimSpace(cfg.DNS.OwnerUserID)
@@ -110,6 +129,30 @@ func (s *Server) listDNSAccounts(c *gin.Context) {
c.JSON(http.StatusOK, gin.H{"items": items})
}
func (s *Server) managedDNSAccountView(c *gin.Context, account domain.DNSAccount) (dnsAccountView, error) {
item := dnsAccountView{
ID: account.ID, Name: account.Name, Provider: account.Provider, ProviderName: "未知服务商",
ProjectID: account.ProjectID, OwnerUserID: account.OwnerUserID,
OwnerUsername: "原用户已不存在", OwnerState: "missing",
VerificationState: account.VerificationState, CredentialState: "stored",
AccountIdentifier: "凭据已隐藏", Status: account.Status, Revision: account.Revision, Managed: true,
}
if descriptor, err := dnsprovider.GetDescriptor(account.Provider); err == nil {
item.ProviderName = descriptor.Name
}
if s.users == nil {
return dnsAccountView{}, errors.New("用户归属查询暂不可用")
}
owner, err := s.users.GetUserByID(c.Request.Context(), account.OwnerUserID)
if err != nil && !errors.Is(err, sql.ErrNoRows) {
return dnsAccountView{}, err
}
if err == nil {
item.OwnerUsername, item.OwnerState = owner.Username, "assigned"
}
return item, nil
}
// dnsAccountIdentifier 只允许输出公开标识的脱敏结果,绝不输出令牌或私钥片段。
func dnsAccountIdentifier(provider string, credentials map[string]string) string {
var value string
@@ -14,6 +14,12 @@ func (s *Server) registerProjectResourceRoutes() {
api := s.router.Group("/api/v1", privateProjectResponse, s.requireAuthenticated)
api.GET("/domains", s.listDomains)
api.GET("/dns/accounts", s.listDNSAccounts)
api.GET("/dns/accounts/:id", s.getManagedDNSAccount)
api.POST("/dns/accounts", s.requireSameOrigin, s.createManagedDNSAccount)
api.PUT("/dns/accounts/:id", s.requireSameOrigin, s.renameManagedDNSAccount)
api.PUT("/dns/accounts/:id/status", s.requireSameOrigin, s.setManagedDNSAccountStatus)
api.PUT("/dns/accounts/:id/credentials", s.requireSameOrigin, s.rotateManagedDNSAccountCredential)
api.POST("/dns/accounts/:id/verify", s.requireSameOrigin, s.dnsOperation, s.verifyManagedDNSAccount)
api.GET("/audit-logs", s.listAuditLogs)
api.GET("/servers", s.listServers)
api.GET("/servers/:id", s.getServer)
+3
View File
@@ -57,6 +57,7 @@ type Dependencies struct {
DeploymentFactory deployment.ClientFactory
RecoveryInspection localRecoveryReader
SetupDNS setupDNSVerifier
DNSAccountVerifier dnsAccountVerifier
Secrets setupSecretWriter
Firewall firewall.Manager
IssueCertificate func(context.Context, string) (certificate.IssueResult, deployment.Report, error)
@@ -103,6 +104,7 @@ type Server struct {
deploymentFactory deployment.ClientFactory
recoveryInspection localRecoveryReader
setupDNS setupDNSVerifier
dnsAccountVerifier dnsAccountVerifier
secrets setupSecretWriter
firewall firewall.Manager
issueCertificate func(context.Context, string) (certificate.IssueResult, deployment.Report, error)
@@ -171,6 +173,7 @@ func New(deps Dependencies) *Server {
servers: deps.Servers,
users: deps.Users,
projectMembers: deps.ProjectMembers,
dnsAccountVerifier: deps.DNSAccountVerifier,
projectDirectory: deps.ProjectDirectory,
projectLifecycle: deps.ProjectLifecycle,
projectResources: deps.ProjectResources,
@@ -19,6 +19,7 @@ type DNSAccountRepository interface {
ListVisibleDNSAccounts(context.Context, string) ([]domain.DNSAccount, error)
GetVisibleDNSAccount(context.Context, string, string) (domain.DNSAccount, error)
GetDNSAccountForUse(context.Context, string, string, string) (domain.DNSAccount, error)
GetDNSAccountForVerification(context.Context, string, string) (domain.DNSAccount, error)
RenameDNSAccount(context.Context, string, string, int64, string) (domain.DNSAccount, error)
SetDNSAccountEnabled(context.Context, string, string, int64, bool) (domain.DNSAccount, error)
RotateDNSAccountCredential(context.Context, string, string, int64, string) (domain.DNSAccount, error)
@@ -138,6 +139,22 @@ func (r *SQLProjectMemberRepository) RenameDNSAccount(ctx context.Context, actor
})
}
// 首次验证允许读取尚未验证的账户,但必须实时拥有管理权限,且账户未被禁用。
// 结果落库仍须核对读取时版本,不能将此快照作为长时间授权或执行租约。
func (r *SQLProjectMemberRepository) GetDNSAccountForVerification(ctx context.Context, actorID, id string) (domain.DNSAccount, error) {
if err := r.resourceReaderReady(actorID); err != nil {
return domain.DNSAccount{}, err
}
predicate, args := resourceReadPredicate("dns_accounts.project_id", actorID, domain.PermissionDNSManage)
args = append(args, id, domain.DNSAccountActive)
item, err := scanDNSAccount(r.db.QueryRowContext(ctx, Rebind(r.driver, `SELECT `+dnsAccountColumns+` FROM dns_accounts WHERE `+predicate+`
AND dns_accounts.id = ? AND dns_accounts.status = ?`), args...))
if errors.Is(err, sql.ErrNoRows) {
return domain.DNSAccount{}, ErrProjectAccessDenied
}
return item, err
}
func (r *SQLProjectMemberRepository) SetDNSAccountEnabled(ctx context.Context, actorID, id string, revision int64, enabled bool) (domain.DNSAccount, error) {
return r.changeDNSAccount(ctx, actorID, id, revision, "dns_account.status", func(item *domain.DNSAccount) error {
item.Status = domain.DNSAccountDisabled
@@ -19,8 +19,11 @@ func TestDNSAccountRepository(t *testing.T) {
t.Run(driver, func(t *testing.T) {
cfg := config.Default(t.TempDir()).Database
cfg.DSN = filepath.Join(t.TempDir(), "dns-accounts.db")
var admin *sql.DB
if driver == "mysql" {
cfg = mysqltest.New(t).Database(t)
server := mysqltest.New(t)
cfg = server.Database(t)
admin = server.Admin()
}
if driver == "postgres" {
cfg = postgrestest.New(t).Database(t)
@@ -33,12 +36,12 @@ func TestDNSAccountRepository(t *testing.T) {
if err := database.Migrate(t.Context(), db.DB, driver); err != nil {
t.Fatal(err)
}
checkDNSAccountRepository(t, db.DB, driver)
checkDNSAccountRepository(t, db.DB, admin, driver)
})
}
}
func checkDNSAccountRepository(t *testing.T, db *sql.DB, driver string) {
func checkDNSAccountRepository(t *testing.T, db, admin *sql.DB, driver string) {
t.Helper()
repo := NewSQLProjectMemberRepository(db, driver)
for _, actor := range []struct{ id, role string }{
@@ -101,6 +104,17 @@ func checkDNSAccountRepository(t *testing.T, db *sql.DB, driver string) {
if _, err := repo.GetDNSAccountForUse(t.Context(), "dns", a.ID, "dns-a"); !errors.Is(err, ErrProjectAccessDenied) {
t.Fatal("未验证账户可被使用", err)
}
for _, actor := range []string{"root", "manager", "dns"} {
item, err := repo.GetDNSAccountForVerification(t.Context(), actor, a.ID)
if err != nil || item.CredentialRef == "" || item.Revision != a.Revision {
t.Fatal("管理角色无法开始首次验证", actor, err)
}
}
for _, actor := range []string{"reader", "cert", "audit", "outsider", "missing"} {
if _, err := repo.GetDNSAccountForVerification(t.Context(), actor, a.ID); !errors.Is(err, ErrProjectAccessDenied) {
t.Fatal("无管理权限取得待验证凭据", actor, err)
}
}
a, err = repo.RecordDNSAccountVerification(t.Context(), "dns", a.ID, a.Revision, true)
if err != nil || a.Revision != 2 {
t.Fatal(err)
@@ -146,6 +160,9 @@ func checkDNSAccountRepository(t *testing.T, db *sql.DB, driver string) {
if _, err := repo.GetDNSAccountForUse(t.Context(), "root", a.ID, "dns-a"); !errors.Is(err, ErrProjectAccessDenied) {
t.Fatal("禁用账户允许使用", err)
}
if _, err := repo.GetDNSAccountForVerification(t.Context(), "root", a.ID); !errors.Is(err, ErrProjectAccessDenied) {
t.Fatal("禁用账户可开始验证", err)
}
a, err = repo.SetDNSAccountEnabled(t.Context(), "manager", a.ID, a.Revision, true)
if err != nil {
t.Fatal(err)
@@ -224,17 +241,25 @@ func checkDNSAccountRepository(t *testing.T, db *sql.DB, driver string) {
t.Fatal("并发失败留下多余审计", err)
}
var rejection []string
executor := db
switch driver {
case "sqlite":
rejection = []string{`CREATE TRIGGER reject_dns_audit BEFORE INSERT ON audit_logs WHEN NEW.resource_type='dns_account' BEGIN SELECT RAISE(ABORT, 'blocked'); END`}
case "mysql":
rejection = []string{`CREATE TRIGGER reject_dns_audit BEFORE INSERT ON audit_logs FOR EACH ROW SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT='blocked'`}
// 仅隔离库故障注入使用管理连接,业务仓储仍使用受限账户,不放宽全局权限。
var schema string
if err := db.QueryRowContext(t.Context(), "SELECT DATABASE()").Scan(&schema); err != nil {
t.Fatal(err)
}
schema = "`" + strings.ReplaceAll(schema, "`", "``") + "`"
rejection = []string{`CREATE TRIGGER ` + schema + `.reject_dns_audit BEFORE INSERT ON ` + schema + `.audit_logs FOR EACH ROW SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT='blocked'`}
executor = admin
case "postgres":
rejection = []string{`CREATE FUNCTION reject_dns_audit() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN RAISE EXCEPTION 'blocked'; END $$`,
`CREATE TRIGGER reject_dns_audit BEFORE INSERT ON audit_logs FOR EACH ROW EXECUTE FUNCTION reject_dns_audit()`}
}
for _, statement := range rejection {
if _, err := db.ExecContext(t.Context(), statement); err != nil {
if _, err := executor.ExecContext(t.Context(), statement); err != nil {
t.Fatal(err)
}
}
@@ -33,7 +33,7 @@ const visibleDomainSelect = `SELECT domains.id, domains.name, domains.certificat
func resourceReadPredicate(projectColumn, actorID string, permission domain.ProjectPermission) (string, []any) {
valid := projectColumn == "domains.project_id" && permission == domain.PermissionCertificateRead ||
projectColumn == "servers.project_id" && permission == domain.PermissionServerRead ||
projectColumn == "dns_accounts.project_id" && (permission == domain.PermissionDNSRead || permission == domain.PermissionDNSCredentialUse)
projectColumn == "dns_accounts.project_id" && (permission == domain.PermissionDNSRead || permission == domain.PermissionDNSCredentialUse || permission == domain.PermissionDNSManage)
if !valid {
return "1 = 0", nil
}