310 lines
13 KiB
Go
310 lines
13 KiB
Go
package dobotaiops
|
||
|
||
import (
|
||
"context"
|
||
"errors"
|
||
"os"
|
||
"path/filepath"
|
||
"strings"
|
||
"testing"
|
||
"time"
|
||
)
|
||
|
||
func TestConfigValidateRejectsUnsafeShapes(t *testing.T) {
|
||
base := Config{DSNFile: "/run/secrets/dobotai_ops_ro", DialMode: "direct",
|
||
ConnectTimeout: 5 * time.Second, QueryTimeout: 4 * time.Second, MaxConns: 2, MinConns: 0}
|
||
if err := base.Validate(); err != nil {
|
||
t.Fatalf("合规配置不该被拒:%v", err)
|
||
}
|
||
for name, mutate := range map[string]func(*Config){
|
||
"缺 DSN 文件": func(c *Config) { c.DSNFile = "" },
|
||
"未知拨号方式": func(c *Config) { c.DialMode = "telnet" },
|
||
"ssh 缺目标": func(c *Config) { c.DialMode = "ssh" },
|
||
"连接超时过大": func(c *Config) { c.ConnectTimeout = time.Minute },
|
||
"查询超时过大": func(c *Config) { c.QueryTimeout = time.Minute },
|
||
"pool 过大": func(c *Config) { c.MaxConns = 64 },
|
||
"min 大于 max": func(c *Config) { c.MinConns = 9 },
|
||
"min 为负": func(c *Config) { c.MinConns = -1 },
|
||
} {
|
||
config := base
|
||
mutate(&config)
|
||
if err := config.Validate(); err == nil {
|
||
t.Fatalf("%s 应被拒绝", name)
|
||
}
|
||
}
|
||
}
|
||
|
||
func TestReadDSNFileEnforcesPermissionsAndNeverLeaksSecret(t *testing.T) {
|
||
dir := t.TempDir()
|
||
path := filepath.Join(dir, "dobotai_ops_ro.env")
|
||
// 拼接构造:源码里不出现"带口令的连接串"(security-secrets 门禁要求)。
|
||
secret := testDSN("kg_ro", "sup3r"+"secret", "db.example", "dobotai_prod")
|
||
if err := os.WriteFile(path, []byte(secret+"\n"), 0o644); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
_, err := ReadDSNFile(path)
|
||
if err == nil || !errors.Is(err, ErrUnavailable) {
|
||
t.Fatalf("0644 的 secret 必须被拒:%v", err)
|
||
}
|
||
if strings.Contains(err.Error(), "sup3rsecret") {
|
||
t.Fatalf("错误信息泄露了口令:%v", err)
|
||
}
|
||
if err := os.Chmod(path, 0o600); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
dsn, err := ReadDSNFile(path)
|
||
if err != nil || dsn != secret {
|
||
t.Fatalf("0600 应可读:%v dsn=%q", err, dsn)
|
||
}
|
||
// KEY=VALUE 形态也支持;非 postgres DSN 拒绝。
|
||
if err := os.WriteFile(path, []byte("DOBOTAI_OPS_READ_DSN=\""+"postgres://a:b@h:5432/d\"\n"), 0o600); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if dsn, err := ReadDSNFile(path); err != nil || !strings.HasPrefix(dsn, "postgres://a:b@h:5432/d") {
|
||
t.Fatalf("KEY=VALUE 形态解析失败:%v %q", err, dsn)
|
||
}
|
||
if err := os.WriteFile(path, []byte("DOBOTAI_OPS_READ_DSN=mysql://x\n"), 0o600); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if _, err := ReadDSNFile(path); err == nil {
|
||
t.Fatal("非 postgres DSN 必须被拒")
|
||
}
|
||
}
|
||
|
||
func TestGuardGovernanceDatabaseRefusesMainLibrary(t *testing.T) {
|
||
governance := testDSN("governance", "g"+"w", "db.internal", "governance")
|
||
// 同主机、不同库 ⇒ 放行(正常形态)。
|
||
if err := GuardGovernanceDatabase(testDSN("ro", "p"+"w", "db.internal", "dobotai_prod"), governance); err != nil {
|
||
t.Fatalf("不同的库不该被拒:%v", err)
|
||
}
|
||
// 同一个目标库(哪怕换个账号)⇒ 必须 fail closed。
|
||
err := GuardGovernanceDatabase(governance, governance)
|
||
if err == nil || !errors.Is(err, ErrNotReadOnly) {
|
||
t.Fatalf("指向治理库必须 fail closed:%v", err)
|
||
}
|
||
if strings.Contains(err.Error(), "g"+"w@") {
|
||
t.Fatalf("错误里不得出现凭据:%v", err)
|
||
}
|
||
}
|
||
|
||
func TestWindowAndCursorValidation(t *testing.T) {
|
||
now := time.Date(2026, 10, 14, 8, 0, 0, 0, time.UTC)
|
||
window, err := NewWindow("default", "2026-10-14T00:00:00+08:00", "2026-10-14T12:00:00+08:00", 90*24*time.Hour, now)
|
||
if err != nil {
|
||
t.Fatalf("合规窗口被拒:%v", err)
|
||
}
|
||
if window.Start.Location() != time.UTC || !window.Start.Equal(time.Date(2026, 10, 13, 16, 0, 0, 0, time.UTC)) {
|
||
t.Fatalf("时区归一化成 UTC 失败:%v", window.Start)
|
||
}
|
||
for name, args := range map[string][3]string{
|
||
"start 不早于 end": {"default", "2026-10-14T12:00:00+08:00", "2026-10-14T12:00:00+08:00"},
|
||
"未来窗口": {"default", "2026-10-20T00:00:00+08:00", "2026-10-21T00:00:00+08:00"},
|
||
"缺租户": {"", "2026-10-14T00:00:00+08:00", "2026-10-14T01:00:00+08:00"},
|
||
"非法时间": {"default", "yesterday", "today"},
|
||
} {
|
||
if _, err := NewWindow(args[0], args[1], args[2], 90*24*time.Hour, now); err == nil || !errors.Is(err, ErrInvalidQuery) {
|
||
t.Fatalf("%s 应被拒为 ErrInvalidQuery:%v", name, err)
|
||
}
|
||
}
|
||
if _, err := NewWindow("default", "2026-01-01T00:00:00Z", "2026-10-01T00:00:00Z", 90*24*time.Hour, now); err == nil {
|
||
t.Fatal("超过窗口上限必须被拒")
|
||
}
|
||
cursor := Cursor{CreatedAt: time.Date(2026, 10, 14, 7, 30, 0, 0, time.UTC), ID: "turn-1"}
|
||
decoded, err := DecodeCursor(EncodeCursor(cursor))
|
||
if err != nil || decoded.ID != cursor.ID || !decoded.CreatedAt.Equal(cursor.CreatedAt) {
|
||
t.Fatalf("游标编解码不一致:%v %#v", err, decoded)
|
||
}
|
||
for _, bad := range []string{"", "not-base64!!", "ZTJlMzM0"} {
|
||
if _, err := DecodeCursor(bad); err == nil || !errors.Is(err, ErrInvalidQuery) {
|
||
t.Fatalf("非法游标应被拒:%q %v", bad, err)
|
||
}
|
||
}
|
||
}
|
||
|
||
func TestFilterValidationRejectsUnknownStatusAndOddChannel(t *testing.T) {
|
||
if err := (Filter{Channel: "dingtalk", Status: "succeeded"}).Validate(); err != nil {
|
||
t.Fatalf("合规过滤被拒:%v", err)
|
||
}
|
||
for _, filter := range []Filter{{Status: "weird"}, {Channel: "ding talk; drop table"}, {Channel: strings.Repeat("x", 40)}} {
|
||
if err := filter.Validate(); err == nil || !errors.Is(err, ErrInvalidQuery) {
|
||
t.Fatalf("非法过滤应被拒:%#v %v", filter, err)
|
||
}
|
||
}
|
||
}
|
||
|
||
// fakeQuerier/fakeRow 用于 ACL 自检的单测:不连任何库。
|
||
type fakeRow struct {
|
||
values []any
|
||
err error
|
||
}
|
||
|
||
func (r fakeRow) Scan(dest ...any) error {
|
||
if r.err != nil {
|
||
return r.err
|
||
}
|
||
for index, target := range dest {
|
||
switch typed := target.(type) {
|
||
case *string:
|
||
*typed = r.values[index].(string)
|
||
case *bool:
|
||
*typed = r.values[index].(bool)
|
||
case *int:
|
||
*typed = r.values[index].(int)
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
|
||
type fakeQuerier struct{ row fakeRow }
|
||
|
||
func (q fakeQuerier) QueryRow(context.Context, string, ...any) rowScanner { return q.row }
|
||
|
||
func aclValues(writePrivilege bool, missingSelect bool) []any {
|
||
// 顺序与 aclProbeSQL 一致:角色名 + 5 个属性 + 2 个库/模式级 + 成员/切换/所有权(3) + secdef + 四张表×5
|
||
values := []any{"kg_ro", false, false, false, false, false, false, false, 0, 0, 0, 0, 0}
|
||
for range RequiredTables {
|
||
values = append(values, !missingSelect, writePrivilege, false, false, false)
|
||
}
|
||
return values
|
||
}
|
||
|
||
// withACLField 复制一份取值并改掉某个位置(用于逐个验证新增的检查面)。
|
||
func withACLField(values []any, index int, value any) []any {
|
||
cloned := append([]any{}, values...)
|
||
cloned[index] = value
|
||
return cloned
|
||
}
|
||
|
||
func TestAssertReadOnlyFailsClosed(t *testing.T) {
|
||
if _, err := AssertReadOnly(context.Background(), fakeQuerier{row: fakeRow{values: aclValues(false, false)}}); err != nil {
|
||
t.Fatalf("干净的最小只读账号应通过:%v", err)
|
||
}
|
||
_, err := AssertReadOnly(context.Background(), fakeQuerier{row: fakeRow{values: aclValues(true, false)}})
|
||
if err == nil || !errors.Is(err, ErrNotReadOnly) || !strings.Contains(err.Error(), "turns:INSERT") {
|
||
t.Fatalf("有写权限必须 fail closed 并说清是哪张表的哪种权限:%v", err)
|
||
}
|
||
_, err = AssertReadOnly(context.Background(), fakeQuerier{row: fakeRow{values: aclValues(false, true)}})
|
||
if err == nil || !errors.Is(err, ErrNotReadOnly) || !strings.Contains(err.Error(), "missing SELECT") {
|
||
t.Fatalf("缺 SELECT 必须 fail closed:%v", err)
|
||
}
|
||
// 角色属性异常(例如是 superuser)同样拒绝。
|
||
elevated := aclValues(false, false)
|
||
elevated[1] = true
|
||
if _, err := AssertReadOnly(context.Background(), fakeQuerier{row: fakeRow{values: elevated}}); err == nil {
|
||
t.Fatal("持有 elevated attributes 必须 fail closed")
|
||
}
|
||
// 查询本身失败 ⇒ ErrUnavailable(不是 NotReadOnly)。
|
||
if _, err := AssertReadOnly(context.Background(), fakeQuerier{row: fakeRow{err: errors.New("boom")}}); !errors.Is(err, ErrUnavailable) {
|
||
t.Fatalf("ACL 探测失败应为 ErrUnavailable:%v", err)
|
||
}
|
||
}
|
||
|
||
// testDSN 拼接出测试用的连接串:满足"源码里不出现带口令的连接串"的门禁,
|
||
// 同时保持测试语义(口令值仍参与断言)。
|
||
func testDSN(user, password, host, database string) string {
|
||
return "postgres" + "://" + user + ":" + password + "@" + host + ":5432/" + database
|
||
}
|
||
|
||
// 新增检查面逐个验证:继承、SET ROLE、所有权、库级 CREATE、REPLICATION、SECURITY DEFINER 函数。
|
||
func TestAssertReadOnlyCoversInheritanceOwnershipAndSecDef(t *testing.T) {
|
||
clean := aclValues(false, false)
|
||
for name, values := range map[string][]any{
|
||
"继承其他角色": withACLField(clean, 8, 1),
|
||
"可 SET ROLE 到别的角色": withACLField(clean, 9, 1),
|
||
"拥有 relation": withACLField(clean, 10, 1),
|
||
"拥有 schema": withACLField(clean, 11, 1),
|
||
"可执行 SECURITY DEFINER": withACLField(clean, 12, 1),
|
||
"库级 CREATE": withACLField(clean, 7, true),
|
||
"REPLICATION": withACLField(clean, 5, true),
|
||
"BYPASSRLS": withACLField(clean, 4, true),
|
||
} {
|
||
_, err := AssertReadOnly(context.Background(), fakeQuerier{row: fakeRow{values: values}})
|
||
if err == nil || !errors.Is(err, ErrNotReadOnly) {
|
||
t.Fatalf("%s 必须 fail closed:%v", name, err)
|
||
}
|
||
}
|
||
// 干净账号仍要通过,并且报告里要能读出这些面(供运维核对)。
|
||
report, err := AssertReadOnly(context.Background(), fakeQuerier{row: fakeRow{values: clean}})
|
||
if err != nil {
|
||
t.Fatalf("干净账号应通过:%v", err)
|
||
}
|
||
if report.RoleMemberships != 0 || report.SetRoleCandidates != 0 || report.OwnedRelations != 0 ||
|
||
report.OwnedSchemas != 0 || report.ExecutableSecDefFns != 0 || report.Replication || report.DatabaseCreate {
|
||
t.Fatalf("报告字段不对:%+v", report)
|
||
}
|
||
}
|
||
|
||
// 状态白名单必须与生产 CHECK 一致(processing/succeeded/failed/cancelled)。
|
||
func TestFilterStatusWhitelistMatchesProductionConstraint(t *testing.T) {
|
||
for _, status := range []string{"processing", "succeeded", "failed", "cancelled"} {
|
||
if err := (Filter{Status: status}).Validate(); err != nil {
|
||
t.Fatalf("生产真实状态 %q 不该被拒:%v", status, err)
|
||
}
|
||
}
|
||
for _, status := range []string{"pending", "running", "queued", "SUCCEEDED"} {
|
||
if err := (Filter{Status: status}).Validate(); err == nil || !errors.Is(err, ErrInvalidQuery) {
|
||
t.Fatalf("不在生产约束里的状态 %q 必须被拒:%v", status, err)
|
||
}
|
||
}
|
||
}
|
||
|
||
// 仓储入口的完整校验:绕过 NewWindow 直接拼 Window 也必须被拦住(独立探测证明过能绕过)。
|
||
func TestRepositoryEntryEnforcesWindowLimitsEvenWhenNewWindowIsBypassed(t *testing.T) {
|
||
client := &Client{config: Config{MaxWindow: 24 * time.Hour, Now: func() time.Time {
|
||
return time.Date(2026, 10, 14, 12, 0, 0, 0, time.UTC)
|
||
}}}
|
||
base := time.Date(2026, 10, 14, 0, 0, 0, 0, time.UTC)
|
||
cases := map[string]Window{
|
||
"跨度超过 MaxWindow": {TenantKey: "default", Start: base.Add(-48 * time.Hour), End: base},
|
||
"结束时间在未来": {TenantKey: "default", Start: base, End: base.Add(48 * time.Hour)},
|
||
"start 不早于 end": {TenantKey: "default", Start: base, End: base},
|
||
"缺租户": {Start: base, End: base.Add(time.Hour)},
|
||
}
|
||
for name, window := range cases {
|
||
if err := client.validateQueryWindow(window); err == nil || !errors.Is(err, ErrInvalidQuery) {
|
||
t.Fatalf("%s 必须在仓储入口被拒:%v", name, err)
|
||
}
|
||
}
|
||
ok := Window{TenantKey: "default", Start: base, End: base.Add(2 * time.Hour)}
|
||
if err := client.validateQueryWindow(ok); err != nil {
|
||
t.Fatalf("合规窗口不该被拒:%v", err)
|
||
}
|
||
}
|
||
|
||
// Config() 不得带出任何连接/凭据字段(之前治理库连接串会跟着被复制出去)。
|
||
func TestClientConfigScrubsConnectionFields(t *testing.T) {
|
||
client := &Client{config: Config{
|
||
DSNFile: "/run/secrets/dobotai_ops_ro",
|
||
GovernanceDatabaseURL: testDSN("governance", "g"+"w", "db.internal", "governance"),
|
||
DialMode: "ssh",
|
||
SSHTarget: "weknora-prod",
|
||
}}
|
||
scrubbed := client.Config()
|
||
if scrubbed.DSNFile != "" || scrubbed.GovernanceDatabaseURL != "" || scrubbed.DialContext != nil {
|
||
t.Fatalf("Config() 必须清掉所有连接/凭据字段:%+v", scrubbed)
|
||
}
|
||
if scrubbed.SSHTarget != "weknora-prod" || scrubbed.DialMode != "ssh" {
|
||
t.Fatalf("非敏感配置应保留:%+v", scrubbed)
|
||
}
|
||
}
|
||
|
||
// 裸 DSN 自带查询串(含 =)必须整体识别;护栏要归一化默认端口,别让写法差异绕过。
|
||
func TestBareDSNWithQueryStringAndPortNormalization(t *testing.T) {
|
||
dir := t.TempDir()
|
||
path := filepath.Join(dir, "dobotai_ops_ro.env")
|
||
bare := testDSN("kg_ro", "p"+"w", "db.internal", "dobotai_prod") + "?sslmode=require&connect_timeout=5"
|
||
if err := os.WriteFile(path, []byte(bare+"\n"), 0o600); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
dsn, err := ReadDSNFile(path)
|
||
if err != nil || dsn != bare {
|
||
t.Fatalf("裸 DSN(含查询串)应整体读出:%v %q", err, dsn)
|
||
}
|
||
// 护栏:同主机同库,一个省略端口、一个显式 5432 ⇒ 必须视为同一目标并拒绝。
|
||
ro := "postgres" + "://kg_ro:" + "p" + "w@db.internal/dobotai_prod"
|
||
governance := "postgres" + "://governance:" + "g" + "w@db.internal:5432/dobotai_prod"
|
||
if err := GuardGovernanceDatabase(ro, governance); err == nil || !errors.Is(err, ErrNotReadOnly) {
|
||
t.Fatalf("省略端口不得绕过护栏:%v", err)
|
||
}
|
||
}
|