保存 DNS 多账户数据层与实库故障夹具修复前检查点

基础模型和迁移已完成;增量竞态暴露 MySQL 审计故障注入权限问题,后续修复,不代表完整功能或验收通过。
This commit is contained in:
xuans committed 2026-10-04 04:42:39 +08:00
1 parent 26b8c3c5c0
commit 02e039984a
19 files changed
+1000 -11

No files matched your search

@@ -0,0 +1,233 @@
package repository
import (
"context"
"database/sql"
"errors"
"fmt"
"time"
"git.pcux.cn/xuans/Scert/backend/internal/domain"
)
var ErrDNSAccountConflict = errors.New("DNS 账户已变更,请刷新后重试")
// DNSAccountRepository 的公开读取不返回凭据引用;秘密读取只能使用独立的使用权限入口。
// 删除及运行租约将在域名绑定接入后提供,当前不提供无引用保护的删除方法。
type DNSAccountRepository interface {
CreateDNSAccount(context.Context, string, domain.DNSAccount) (domain.DNSAccount, error)
ListVisibleDNSAccounts(context.Context, string) ([]domain.DNSAccount, error)
GetVisibleDNSAccount(context.Context, string, string) (domain.DNSAccount, error)
GetDNSAccountForUse(context.Context, string, 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)
RecordDNSAccountVerification(context.Context, string, string, int64, bool) (domain.DNSAccount, error)
}
var _ DNSAccountRepository = (*SQLProjectMemberRepository)(nil)
const dnsAccountColumns = `dns_accounts.id, dns_accounts.name, dns_accounts.project_id,
dns_accounts.owner_user_id, dns_accounts.provider, dns_accounts.credential_ref,
dns_accounts.status, dns_accounts.verification_state, dns_accounts.revision,
dns_accounts.created_at, dns_accounts.updated_at`
func scanDNSAccount(row scanner) (domain.DNSAccount, error) {
var item domain.DNSAccount
err := row.Scan(&item.ID, &item.Name, &item.ProjectID, &item.OwnerUserID, &item.Provider,
&item.CredentialRef, &item.Status, &item.VerificationState, &item.Revision, &item.CreatedAt, &item.UpdatedAt)
return item, err
}
func publicDNSAccount(item domain.DNSAccount) domain.DNSAccount {
item.CredentialRef = ""
return item
}
func (r *SQLProjectMemberRepository) CreateDNSAccount(ctx context.Context, actorID string, item domain.DNSAccount) (domain.DNSAccount, error) {
if err := r.ensureDB(); err != nil {
return domain.DNSAccount{}, err
}
// 用户归属、初始验证状态及版本只由服务端生成,不能由请求冒领或伪造验证成功。
item.OwnerUserID, item.Revision = actorID, 1
item.Status, item.VerificationState = domain.DNSAccountActive, domain.DNSAccountUnverified
item.CreatedAt = time.Now().UTC()
item.UpdatedAt = item.CreatedAt
if err := item.Validate(); err != nil {
return domain.DNSAccount{}, err
}
tx, err := r.db.BeginTx(ctx, nil)
if err != nil {
return domain.DNSAccount{}, err
}
defer tx.Rollback()
if err := r.authorizeProjectTransaction(ctx, tx, actorID, item.ProjectID, domain.PermissionDNSManage); err != nil {
return domain.DNSAccount{}, err
}
_, err = tx.ExecContext(ctx, Rebind(r.driver, `INSERT INTO dns_accounts
(id, name, project_id, owner_user_id, provider, credential_ref, status, verification_state, revision, created_at, updated_at)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`), item.ID, item.Name, item.ProjectID, item.OwnerUserID,
item.Provider, item.CredentialRef, item.Status, item.VerificationState, item.Revision, item.CreatedAt, item.UpdatedAt)
if err != nil {
// 驱动错误可能回显唯一键中的凭据引用,不把原始错误传向外部接口。
return domain.DNSAccount{}, errors.New("保存 DNS 账户失败,请检查账户或凭据引用是否重复")
}
if err := writeDNSAccountAudit(ctx, tx, r.driver, actorID, item, "dns_account.create"); err != nil {
return domain.DNSAccount{}, err
}
if err := tx.Commit(); err != nil {
return domain.DNSAccount{}, err
}
return publicDNSAccount(item), nil
}
func (r *SQLProjectMemberRepository) ListVisibleDNSAccounts(ctx context.Context, actorID string) ([]domain.DNSAccount, error) {
if err := r.resourceReaderReady(actorID); err != nil {
return nil, err
}
predicate, args := resourceReadPredicate("dns_accounts.project_id", actorID, domain.PermissionDNSRead)
rows, err := r.db.QueryContext(ctx, Rebind(r.driver, `SELECT `+dnsAccountColumns+` FROM dns_accounts WHERE `+predicate+` ORDER BY dns_accounts.name, dns_accounts.id`), args...)
if err != nil {
return nil, fmt.Errorf("读取 DNS 账户列表失败:%w", err)
}
defer rows.Close()
items := make([]domain.DNSAccount, 0)
for rows.Next() {
item, err := scanDNSAccount(rows)
if err != nil {
return nil, err
}
items = append(items, publicDNSAccount(item))
}
return items, rows.Err()
}
func (r *SQLProjectMemberRepository) GetVisibleDNSAccount(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.PermissionDNSRead)
args = append(args, id)
item, err := scanDNSAccount(r.db.QueryRowContext(ctx, Rebind(r.driver, `SELECT `+dnsAccountColumns+` FROM dns_accounts WHERE `+predicate+` AND dns_accounts.id = ?`), args...))
if errors.Is(err, sql.ErrNoRows) {
return domain.DNSAccount{}, ErrProjectAccessDenied
}
return publicDNSAccount(item), err
}
// GetDNSAccountForUse 要求调用方传真实域名项目;禁用、未验证或跨项目账户不返回秘密引用。
// 返回的是检查时快照,签发执行仍须通过后续租约机制持有版本,不能把此读取当作执行锁。
func (r *SQLProjectMemberRepository) GetDNSAccountForUse(ctx context.Context, actorID, id, projectID string) (domain.DNSAccount, error) {
if err := r.resourceReaderReady(actorID); err != nil {
return domain.DNSAccount{}, err
}
predicate, args := resourceReadPredicate("dns_accounts.project_id", actorID, domain.PermissionDNSCredentialUse)
args = append(args, id, projectID, domain.DNSAccountActive, domain.DNSAccountVerified)
item, err := scanDNSAccount(r.db.QueryRowContext(ctx, Rebind(r.driver, `SELECT `+dnsAccountColumns+` FROM dns_accounts WHERE `+predicate+`
AND dns_accounts.id = ? AND dns_accounts.project_id = ? AND dns_accounts.status = ? AND dns_accounts.verification_state = ?`), args...))
if errors.Is(err, sql.ErrNoRows) {
return domain.DNSAccount{}, ErrProjectAccessDenied
}
return item, err
}
func (r *SQLProjectMemberRepository) RenameDNSAccount(ctx context.Context, actorID, id string, revision int64, name string) (domain.DNSAccount, error) {
return r.changeDNSAccount(ctx, actorID, id, revision, "dns_account.rename", func(item *domain.DNSAccount) error {
item.Name = name
return nil
})
}
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
if enabled {
item.Status = domain.DNSAccountActive
}
return nil
})
}
func (r *SQLProjectMemberRepository) RotateDNSAccountCredential(ctx context.Context, actorID, id string, revision int64, reference string) (domain.DNSAccount, error) {
return r.changeDNSAccount(ctx, actorID, id, revision, "dns_account.rotate", func(item *domain.DNSAccount) error {
if reference == item.CredentialRef {
return errors.New("DNS 凭据轮换必须使用新的秘密引用")
}
item.CredentialRef, item.VerificationState = reference, domain.DNSAccountUnverified
return nil
})
}
// 验证调用者必须先完成真实 DNS 验证;此入口只接受开始验证时的版本,不接受客户端自报结果。
func (r *SQLProjectMemberRepository) RecordDNSAccountVerification(ctx context.Context, actorID, id string, revision int64, success bool) (domain.DNSAccount, error) {
return r.changeDNSAccount(ctx, actorID, id, revision, "dns_account.verify", func(item *domain.DNSAccount) error {
if item.Status != domain.DNSAccountActive {
return errors.New("已禁用的 DNS 账户不能完成验证")
}
item.VerificationState = domain.DNSAccountVerificationFailed
if success {
item.VerificationState = domain.DNSAccountVerified
}
return nil
})
}
func (r *SQLProjectMemberRepository) changeDNSAccount(ctx context.Context, actorID, id string, revision int64, action string, change func(*domain.DNSAccount) error) (domain.DNSAccount, error) {
if err := r.ensureDB(); err != nil {
return domain.DNSAccount{}, err
}
tx, err := r.db.BeginTx(ctx, nil)
if err != nil {
return domain.DNSAccount{}, err
}
defer tx.Rollback()
item, err := scanDNSAccount(tx.QueryRowContext(ctx, Rebind(r.driver, `SELECT `+dnsAccountColumns+` FROM dns_accounts WHERE id = ?`+r.resourceWriteLock()), id))
if errors.Is(err, sql.ErrNoRows) {
return domain.DNSAccount{}, ErrProjectAccessDenied
}
if err != nil {
return domain.DNSAccount{}, err
}
if err := r.authorizeProjectTransaction(ctx, tx, actorID, item.ProjectID, domain.PermissionDNSManage); err != nil {
return domain.DNSAccount{}, err
}
if item.Revision != revision {
return domain.DNSAccount{}, ErrDNSAccountConflict
}
if err := change(&item); err != nil {
return domain.DNSAccount{}, err
}
item.Revision++
item.UpdatedAt = time.Now().UTC()
if err := item.Validate(); err != nil {
return domain.DNSAccount{}, err
}
result, err := tx.ExecContext(ctx, Rebind(r.driver, `UPDATE dns_accounts SET name = ?, credential_ref = ?, status = ?, verification_state = ?, revision = ?, updated_at = ? WHERE id = ? AND revision = ?`),
item.Name, item.CredentialRef, item.Status, item.VerificationState, item.Revision, item.UpdatedAt, item.ID, revision)
if err != nil {
return domain.DNSAccount{}, errors.New("更新 DNS 账户失败,请检查凭据引用是否重复")
}
if count, err := result.RowsAffected(); err != nil || count != 1 {
return domain.DNSAccount{}, ErrDNSAccountConflict
}
if err := writeDNSAccountAudit(ctx, tx, r.driver, actorID, item, action); err != nil {
return domain.DNSAccount{}, err
}
if err := tx.Commit(); err != nil {
return domain.DNSAccount{}, err
}
return publicDNSAccount(item), nil
}
func writeDNSAccountAudit(ctx context.Context, tx *sql.Tx, driver, actorID string, item domain.DNSAccount, action string) error {
result, err := tx.ExecContext(ctx, Rebind(driver, `INSERT INTO audit_logs
(action, resource_type, resource_id, status, message, created_at, scope_type, project_id, task_id, operator_id)
VALUES (?, 'dns_account', ?, 'success', 'DNS 账户资料已更新', ?, 'project', ?, '', ?)`), action, item.ID, time.Now().UTC(), item.ProjectID, actorID)
if err != nil {
return errors.New("写入 DNS 账户审计失败,变更已回滚")
}
if count, err := result.RowsAffected(); err != nil || count != 1 {
return errors.New("DNS 账户审计未保存,变更已回滚")
}
return nil
}
@@ -0,0 +1,254 @@
package repository
import (
"database/sql"
"errors"
"path/filepath"
"strings"
"testing"
"git.pcux.cn/xuans/Scert/backend/internal/config"
"git.pcux.cn/xuans/Scert/backend/internal/database"
"git.pcux.cn/xuans/Scert/backend/internal/domain"
"git.pcux.cn/xuans/Scert/backend/internal/testsupport/mysqltest"
"git.pcux.cn/xuans/Scert/backend/internal/testsupport/postgrestest"
)
func TestDNSAccountRepository(t *testing.T) {
for _, driver := range []string{"sqlite", "mysql", "postgres"} {
t.Run(driver, func(t *testing.T) {
cfg := config.Default(t.TempDir()).Database
cfg.DSN = filepath.Join(t.TempDir(), "dns-accounts.db")
if driver == "mysql" {
cfg = mysqltest.New(t).Database(t)
}
if driver == "postgres" {
cfg = postgrestest.New(t).Database(t)
}
db, err := database.Open(t.Context(), cfg)
if err != nil {
t.Fatal(err)
}
defer db.Close()
if err := database.Migrate(t.Context(), db.DB, driver); err != nil {
t.Fatal(err)
}
checkDNSAccountRepository(t, db.DB, driver)
})
}
}
func checkDNSAccountRepository(t *testing.T, db *sql.DB, driver string) {
t.Helper()
repo := NewSQLProjectMemberRepository(db, driver)
for _, actor := range []struct{ id, role string }{
{"root", "super_admin"}, {"manager", "user"}, {"dns", "user"}, {"reader", "user"},
{"cert", "user"}, {"audit", "user"}, {"outsider", "admin"},
} {
if _, err := db.ExecContext(t.Context(), Rebind(driver, `INSERT INTO users (id,username,password_hash,role,status)
VALUES (?,?,'test-only-no-login',?,'active')`), actor.id, actor.id, actor.role); err != nil {
t.Fatal(err)
}
}
for _, project := range []string{"dns-a", "dns-b"} {
if err := NewSQLProjectRepository(db, driver).CreateProject(t.Context(), domain.Project{ID: project, Name: "DNS 测试项目"}); err != nil {
t.Fatal(err)
}
}
for actor, role := range map[string]domain.ProjectRole{
"manager": domain.ProjectRoleAdmin, "dns": domain.ProjectRoleDNSAdmin, "reader": domain.ProjectRoleReadOnly,
"cert": domain.ProjectRoleCertificateAdmin, "audit": domain.ProjectRoleAuditViewer,
} {
if err := repo.GrantProjectRole(t.Context(), "root", "dns-a", actor, role); err != nil {
t.Fatal(err)
}
}
if err := repo.GrantProjectRole(t.Context(), "root", "dns-a", "manager", domain.ProjectRoleReadOnly); err != nil {
t.Fatal(err)
}
makeAccount := func(id, project string) domain.DNSAccount {
return domain.DNSAccount{ID: id, Name: "账户" + id, ProjectID: project, Provider: "aliyun", CredentialRef: "secret://dns/aliyun/" + id,
OwnerUserID: "forged-owner", VerificationState: domain.DNSAccountVerified, Revision: 999}
}
a, err := repo.CreateDNSAccount(t.Context(), "dns", makeAccount("account-a", "dns-a"))
if err != nil || a.OwnerUserID != "dns" || a.Revision != 1 || a.VerificationState != domain.DNSAccountUnverified || a.CredentialRef != "" {
t.Fatal("创建未固定真实归属或初始状态", a, err)
}
if _, err := repo.CreateDNSAccount(t.Context(), "root", makeAccount("account-b", "dns-b")); err != nil {
t.Fatal(err)
}
for _, actor := range []string{"reader", "cert", "audit", "outsider", "missing"} {
if _, err := repo.CreateDNSAccount(t.Context(), actor, makeAccount("denied", "dns-a")); err == nil {
t.Fatalf("越权创建未拒绝:%s", actor)
}
}
for actor, count := range map[string]int{"root": 2, "manager": 1, "dns": 1, "reader": 1, "cert": 0, "audit": 0, "outsider": 0, "missing": 0} {
items, err := repo.ListVisibleDNSAccounts(t.Context(), actor)
if err != nil || len(items) != count {
t.Fatalf("账户可见范围错误:%s %d %v", actor, len(items), err)
}
for _, item := range items {
if item.CredentialRef != "" {
t.Fatal("列表返回凭据引用")
}
}
}
for _, id := range []string{"account-b", "missing"} {
if _, err := repo.GetVisibleDNSAccount(t.Context(), "dns", id); !errors.Is(err, ErrProjectAccessDenied) {
t.Fatal("跨项目和不存在账户应同样拒绝", err)
}
}
if _, err := repo.GetDNSAccountForUse(t.Context(), "dns", a.ID, "dns-a"); !errors.Is(err, ErrProjectAccessDenied) {
t.Fatal("未验证账户可被使用", err)
}
a, err = repo.RecordDNSAccountVerification(t.Context(), "dns", a.ID, a.Revision, true)
if err != nil || a.Revision != 2 {
t.Fatal(err)
}
used, err := repo.GetDNSAccountForUse(t.Context(), "dns", a.ID, "dns-a")
if err != nil || used.CredentialRef != "secret://dns/aliyun/account-a" {
t.Fatal("已授权使用未取得正确引用", err)
}
if _, err := repo.GetDNSAccountForUse(t.Context(), "root", a.ID, "dns-b"); !errors.Is(err, ErrProjectAccessDenied) {
t.Fatal("超级管理员也不得跨项目使用", err)
}
if _, err := repo.GetDNSAccountForUse(t.Context(), "reader", a.ID, "dns-a"); !errors.Is(err, ErrProjectAccessDenied) {
t.Fatal("只读角色取得凭据引用", err)
}
if _, err := repo.RenameDNSAccount(t.Context(), "outsider", a.ID, a.Revision, "越权"); !errors.Is(err, ErrProjectAccessDenied) {
t.Fatal(err)
}
old := a.Revision
a, err = repo.RotateDNSAccountCredential(t.Context(), "dns", a.ID, old, "secret://dns/aliyun/rotated")
if err != nil || a.VerificationState != domain.DNSAccountUnverified {
t.Fatal("轮换未使验证失效", err)
}
if _, err := repo.RecordDNSAccountVerification(t.Context(), "dns", a.ID, old, true); !errors.Is(err, ErrDNSAccountConflict) {
t.Fatal("旧验证覆盖轮换结果", err)
}
if _, err := repo.RotateDNSAccountCredential(t.Context(), "dns", a.ID, a.Revision, "secret://dns/aliyun/rotated"); err == nil {
t.Fatal("复用旧引用轮换未被拒绝")
}
if _, err := repo.RotateDNSAccountCredential(t.Context(), "dns", a.ID, a.Revision, "secret://dns/aliyun/account-b"); err == nil || strings.Contains(err.Error(), "secret://") {
t.Fatal("重复引用未拒绝或泄露秘密位置", err)
}
old = a.Revision
a, err = repo.SetDNSAccountEnabled(t.Context(), "manager", a.ID, old, false)
if err != nil || a.Status != domain.DNSAccountDisabled {
t.Fatal(err)
}
if _, err := repo.RecordDNSAccountVerification(t.Context(), "dns", a.ID, old, true); !errors.Is(err, ErrDNSAccountConflict) {
t.Fatal("旧验证覆盖禁用状态", err)
}
if _, err := repo.RecordDNSAccountVerification(t.Context(), "dns", a.ID, a.Revision, true); err == nil {
t.Fatal("禁用账户允许完成验证")
}
if _, err := repo.GetDNSAccountForUse(t.Context(), "root", a.ID, "dns-a"); !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)
}
a, err = repo.RecordDNSAccountVerification(t.Context(), "dns", a.ID, a.Revision, false)
if err != nil || a.VerificationState != domain.DNSAccountVerificationFailed {
t.Fatal(err)
}
if _, err := repo.GetDNSAccountForUse(t.Context(), "dns", a.ID, "dns-a"); !errors.Is(err, ErrProjectAccessDenied) {
t.Fatal("验证失败账户可使用", err)
}
a, err = repo.RenameDNSAccount(t.Context(), "manager", a.ID, a.Revision, "轮换后的账户")
if err != nil || a.OwnerUserID != "dns" || a.ProjectID != "dns-a" || a.Provider != "aliyun" {
t.Fatal("修改时归属发生变化", err)
}
if err := repo.RevokeProjectRole(t.Context(), "root", "dns-a", "dns", domain.ProjectRoleDNSAdmin); err != nil {
t.Fatal(err)
}
if _, err := repo.RecordDNSAccountVerification(t.Context(), "dns", a.ID, a.Revision, true); !errors.Is(err, ErrProjectAccessDenied) {
t.Fatal("撤权后验证结果仍可写入", err)
}
if _, err := db.ExecContext(t.Context(), `UPDATE users SET status='disabled' WHERE id='manager'`); err != nil {
t.Fatal(err)
}
items, err := repo.ListVisibleDNSAccounts(t.Context(), "manager")
if err != nil || len(items) != 0 {
t.Fatal("停用账户仍可读取", err)
}
if _, err := repo.RenameDNSAccount(t.Context(), "manager", a.ID, a.Revision, "已停用"); !errors.Is(err, ErrProjectAccessDenied) {
t.Fatal("停用账户仍可修改", err)
}
var count int
if err := db.QueryRowContext(t.Context(), `SELECT COUNT(*) FROM audit_logs WHERE resource_type='dns_account' AND (message LIKE '%secret://%' OR message LIKE '%rotated%')`).Scan(&count); err != nil || count != 0 {
t.Fatal("审计包含秘密引用", err)
}
if err := db.QueryRowContext(t.Context(), `SELECT COUNT(*) FROM audit_logs WHERE resource_type='dns_account' AND resource_id='account-a'`).Scan(&count); err != nil || int64(count) != a.Revision {
t.Fatal("成功修订与事务审计数量不一致", count, a.Revision, err)
}
if _, err := db.ExecContext(t.Context(), `DELETE FROM projects WHERE id='dns-b'`); err == nil {
t.Fatal("删除项目产生孤立 DNS 账户")
}
concurrent, err := repo.CreateDNSAccount(t.Context(), "root", makeAccount("concurrent", "dns-a"))
if err != nil {
t.Fatal(err)
}
start := make(chan struct{})
results := make(chan error, 2)
go func() {
<-start
_, err := repo.RenameDNSAccount(t.Context(), "root", concurrent.ID, concurrent.Revision, "并发改名")
results <- err
}()
go func() {
<-start
_, err := repo.SetDNSAccountEnabled(t.Context(), "root", concurrent.ID, concurrent.Revision, false)
results <- err
}()
close(start)
successes := 0
for range 2 {
err := <-results
if err == nil {
successes++
continue
}
if !errors.Is(err, ErrDNSAccountConflict) && !(driver == "sqlite" && strings.Contains(strings.ToLower(err.Error()), "locked")) {
t.Fatal("并发修改出现非预期错误", err)
}
}
stored, err := repo.GetVisibleDNSAccount(t.Context(), "root", concurrent.ID)
if err != nil || successes != 1 || stored.Revision != 2 {
t.Fatal("并发更新没有唯一胜出版本", successes, stored.Revision, err)
}
var auditCount int
if err := db.QueryRowContext(t.Context(), `SELECT COUNT(*) FROM audit_logs WHERE resource_type='dns_account' AND resource_id='concurrent'`).Scan(&auditCount); err != nil || auditCount != 2 {
t.Fatal("并发失败留下多余审计", err)
}
var rejection []string
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'`}
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 {
t.Fatal(err)
}
}
if _, err := repo.RenameDNSAccount(t.Context(), "root", a.ID, a.Revision, "不应写入"); err == nil {
t.Fatal("审计失败未阻止变更")
}
after, err := repo.GetVisibleDNSAccount(t.Context(), "root", a.ID)
if err != nil || after.Name != a.Name || after.Revision != a.Revision {
t.Fatal("审计失败未回滚", err)
}
if _, err := repo.CreateDNSAccount(t.Context(), "root", makeAccount("failed-audit", "dns-a")); err == nil {
t.Fatal("审计失败仍创建账户")
}
if _, err := repo.GetVisibleDNSAccount(t.Context(), "root", "failed-audit"); !errors.Is(err, ErrProjectAccessDenied) {
t.Fatal("创建失败留下账户", err)
}
}
@@ -31,10 +31,10 @@ const visibleDomainSelect = `SELECT domains.id, domains.name, domains.certificat
// 列名只接受内部固定值,角色能力复用领域模型;所有身份和角色值均使用绑定参数。
// EXISTS 避免多角色账户重复返回资源,不按用户分组或全局普通管理员身份放行。
func resourceReadPredicate(projectColumn, actorID string, permission domain.ProjectPermission) (string, []any) {
if projectColumn != "domains.project_id" && projectColumn != "servers.project_id" {
return "1 = 0", nil
}
if permission != domain.PermissionCertificateRead && permission != domain.PermissionServerRead {
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)
if !valid {
return "1 = 0", nil
}
roles := []domain.ProjectRole{