Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

test(audit): pin the store and stream rule on a booted server (#21484)

Vincent Huangd017ffa4fea0
diff --git a/backend/tests/audit_sinks_test.go b/backend/tests/audit_sinks_test.go
new file mode 100644
index 0000000000..9c120b90d8
--- /dev/null
+++ b/backend/tests/audit_sinks_test.go
@@ -0,0 +1,414 @@
+package tests
+
+import (
+ "context"
+ "encoding/base64"
+ "fmt"
+ "net/http"
+ "strings"
+ "testing"
+
+ "connectrpc.com/connect"
+ "github.com/modelcontextprotocol/go-sdk/mcp"
+ "github.com/stretchr/testify/require"
+ "google.golang.org/genproto/googleapis/type/expr"
+ "google.golang.org/protobuf/types/known/fieldmaskpb"
+
+ v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"
+ "github.com/bytebase/bytebase/backend/generated-go/v1/v1connect"
+)
+
+// auditSinkProbe is one call in TestAuditSinksOnBothChains and where it must
+// land.
+type auditSinkProbe struct {
+ name string
+ method string
+ member bool // the caller is the workspace member, not the admin
+ mcp bool
+ // parent is where the row or line is filed.
+ parent string
+ // match picks the probe's own row or line apart from other calls to the
+ // same method by the same caller.
+ match func(request string) bool
+ call func(t *testing.T)
+ checkRow func(t *testing.T, row *v1pb.AuditLog)
+ checkLine func(t *testing.T, line map[string]any)
+ // wantRow is whether the call is stored; wantWarning is whether a
+ // permission check refused it. A line follows from the two: stdout carries
+ // every stored row and every refusal.
+ wantRow bool
+ wantWarning bool
+}
+
+// TestAuditSinksOnBothChains is the store and stream rule on a booted server,
+// through both interceptor chains, with stdout audit on and off:
+//
+// store = audited method and the call reached its handler
+// stream = stdout on and (stored or refused by a permission check)
+//
+// Not parallel: it captures slog.Default.
+func TestAuditSinksOnBothChains(t *testing.T) {
+ a := require.New(t)
+ ctx := context.Background()
+ lines := captureAuditStream(t)
+ ctl, ctx := startWorkspace(ctx, t)
+
+ const memberEmail = "[email protected]"
+ const memberPassword = "1024bytebase"
+ created, err := ctl.userServiceClient.CreateUser(ctx, connect.NewRequest(&v1pb.CreateUserRequest{
+ User: &v1pb.User{Title: "audit sinks member", Email: memberEmail, Password: memberPassword},
+ }))
+ a.NoError(err)
+ _, err = ctl.addMemberToWorkspaceIAM(ctx, created.Msg.Workspace, "user:"+memberEmail, "roles/workspaceMember")
+ a.NoError(err)
+ login, err := ctl.authServiceClient.Login(ctx, connect.NewRequest(&v1pb.LoginRequest{
+ Email: memberEmail, Password: memberPassword,
+ }))
+ a.NoError(err)
+ workspace := login.Msg.GetUser().GetWorkspace()
+ a.NotEmpty(workspace)
+ adminUser, memberUser := ctl.principalName, "users/"+memberEmail
+ // The member holds no role on this project.
+ project := ctl.project.Name
+
+ memberAuth := connect.WithInterceptors(&authInterceptor{token: login.Msg.Token})
+ memberProjects := v1connect.NewProjectServiceClient(ctl.client, ctl.rootURL, memberAuth)
+ memberSettings := v1connect.NewSettingServiceClient(ctl.client, ctl.rootURL, memberAuth)
+ memberIssues := v1connect.NewIssueServiceClient(ctl.client, ctl.rootURL, memberAuth)
+ memberGroups := v1connect.NewDatabaseGroupServiceClient(ctl.client, ctl.rootURL, memberAuth)
+ memberSQL := v1connect.NewSQLServiceClient(ctl.client, ctl.rootURL, memberAuth)
+
+ // grantMemberProjectRole binds the member to one project role and returns
+ // the undo, so a probe that needs the member past the ACL leaves the rest
+ // looking at a member who holds no role.
+ grantMemberProjectRole := func(t *testing.T, role string) func() {
+ t.Helper()
+ set := func(bindings []*v1pb.Binding) {
+ policy, err := ctl.projectServiceClient.GetIamPolicy(ctx, connect.NewRequest(&v1pb.GetIamPolicyRequest{Resource: project}))
+ require.NoError(t, err)
+ var kept []*v1pb.Binding
+ for _, binding := range policy.Msg.Bindings {
+ var members []string
+ for _, member := range binding.Members {
+ if !strings.Contains(member, memberEmail) {
+ members = append(members, member)
+ }
+ }
+ if len(members) > 0 {
+ binding.Members = members
+ kept = append(kept, binding)
+ }
+ }
+ kept = append(kept, bindings...)
+ policy.Msg.Bindings = kept
+ _, err = ctl.projectServiceClient.SetIamPolicy(ctx, connect.NewRequest(&v1pb.SetIamPolicyRequest{
+ Resource: project, Policy: policy.Msg,
+ }))
+ require.NoError(t, err)
+ }
+ set([]*v1pb.Binding{{Role: role, Members: []string{"user:" + memberEmail}}})
+ return func() { set(nil) }
+ }
+
+ // The clamp fixture leaves the ceiling at READ_ONLY; every other MCP probe
+ // runs under READ_WRITE.
+ clamp := setupMCPClampFixture(ctx, t, ctl)
+ a.NoError(ctl.setMCPCapability(ctx, v1pb.MCPSetting_READ_WRITE))
+ adminSession := openMCPSession(ctx, t, ctl, ctl.authInterceptor.token)
+ defer adminSession.Close()
+ memberToken, _ := mintMCPOAuthToken(t, ctl, login.Msg.Token)
+ memberSession := openMCPSession(ctx, t, ctl, memberToken)
+ defer memberSession.Close()
+
+ requireCode := func(t *testing.T, want connect.Code, err error) {
+ t.Helper()
+ if want == 0 {
+ require.NoError(t, err)
+ return
+ }
+ require.Equal(t, want, connect.CodeOf(err), "%v", err)
+ }
+ databaseGroup := func(id string) *v1pb.CreateDatabaseGroupRequest {
+ return &v1pb.CreateDatabaseGroupRequest{
+ Parent: project,
+ DatabaseGroupId: id,
+ DatabaseGroup: &v1pb.DatabaseGroup{Title: id, DatabaseExpr: &expr.Expr{Expression: "true"}},
+ ValidateOnly: true,
+ }
+ }
+ mcpCall := func(session *mcp.ClientSession, operation string, body map[string]any, wantStatus int) func(t *testing.T) {
+ return func(t *testing.T) {
+ out := callAPIOnSession(ctx, t, session, operation, body)
+ require.Equal(t, wantStatus, out.Status, out.Error)
+ }
+ }
+
+ probes := []auditSinkProbe{
+ {
+ name: "public/audited ok", method: v1connect.ProjectServiceUpdateProjectProcedure, parent: project,
+ wantRow: true,
+ call: func(t *testing.T) {
+ _, err := ctl.projectServiceClient.UpdateProject(ctx, connect.NewRequest(&v1pb.UpdateProjectRequest{
+ Project: &v1pb.Project{Name: project, Title: "audit sinks"},
+ UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"title"}},
+ }))
+ requireCode(t, 0, err)
+ },
+ },
+ {
+ name: "public/audited refused in handler", method: v1connect.SettingServiceUpdateSettingProcedure, member: true, parent: workspace,
+ wantRow: true, wantWarning: true,
+ call: func(t *testing.T) {
+ _, err := memberSettings.UpdateSetting(ctx, connect.NewRequest(&v1pb.UpdateSettingRequest{
+ Setting: &v1pb.Setting{Name: "settings/AI"},
+ }))
+ requireCode(t, connect.CodePermissionDenied, err)
+ },
+ },
+ {
+ name: "public/audited refused by ACL", method: v1connect.ProjectServiceUpdateProjectProcedure, member: true, parent: project,
+ wantWarning: true,
+ call: func(t *testing.T) {
+ _, err := memberProjects.UpdateProject(ctx, connect.NewRequest(&v1pb.UpdateProjectRequest{
+ Project: &v1pb.Project{Name: project, Title: "not mine"},
+ UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"title"}},
+ }))
+ requireCode(t, connect.CodePermissionDenied, err)
+ },
+ },
+ {
+ name: "public/unaudited refused in handler", method: v1connect.IssueServiceSearchIssuesProcedure, member: true, parent: workspace,
+ wantWarning: true,
+ call: func(t *testing.T) {
+ _, err := memberIssues.SearchIssues(ctx, connect.NewRequest(&v1pb.SearchIssuesRequest{Parent: project}))
+ requireCode(t, connect.CodePermissionDenied, err)
+ },
+ },
+ {
+ name: "public/unaudited refused by ACL", method: v1connect.ProjectServiceGetProjectProcedure, member: true, parent: project,
+ wantWarning: true,
+ call: func(t *testing.T) {
+ _, err := memberProjects.GetProject(ctx, connect.NewRequest(&v1pb.GetProjectRequest{Name: project}))
+ requireCode(t, connect.CodePermissionDenied, err)
+ },
+ },
+ {
+ name: "public/unaudited ok", method: v1connect.ProjectServiceGetProjectProcedure, parent: project,
+ call: func(t *testing.T) {
+ _, err := ctl.projectServiceClient.GetProject(ctx, connect.NewRequest(&v1pb.GetProjectRequest{Name: project}))
+ requireCode(t, 0, err)
+ },
+ },
+ {
+ name: "public/audited validate-only ok", method: v1connect.DatabaseGroupServiceCreateDatabaseGroupProcedure, parent: project,
+ call: func(t *testing.T) {
+ _, err := ctl.databaseGroupServiceClient.CreateDatabaseGroup(ctx, connect.NewRequest(databaseGroup("sinks-admin")))
+ requireCode(t, 0, err)
+ },
+ },
+ {
+ name: "public/audited validate-only refused by ACL", method: v1connect.DatabaseGroupServiceCreateDatabaseGroupProcedure, member: true, parent: project,
+ wantWarning: true,
+ call: func(t *testing.T) {
+ _, err := memberGroups.CreateDatabaseGroup(ctx, connect.NewRequest(databaseGroup("sinks-member")))
+ requireCode(t, connect.CodePermissionDenied, err)
+ },
+ },
+ {
+ name: "public/audit log search", method: v1connect.AuditLogServiceSearchAuditLogsProcedure, parent: workspace,
+ match: func(request string) bool { return strings.Contains(request, `"pageSize":7`) },
+ wantRow: true,
+ call: func(t *testing.T) {
+ resp, err := ctl.auditLogServiceClient.SearchAuditLogs(ctx, connect.NewRequest(&v1pb.SearchAuditLogsRequest{
+ Parent: workspace, PageSize: 7,
+ }))
+ requireCode(t, 0, err)
+ require.NotEmpty(t, resp.Msg.AuditLogs)
+ },
+ checkRow: func(t *testing.T, row *v1pb.AuditLog) {
+ require.NotContains(t, row.Response, "auditLogs", "a search's row must not copy the rows it read")
+ require.NotEmpty(t, row.Response, "the response was written, minus the rows it read")
+ },
+ },
+ {
+ name: "mcp/audited ok", method: v1connect.SheetServiceCreateSheetProcedure, mcp: true, parent: project,
+ wantRow: true,
+ call: mcpCall(adminSession, "SheetService/CreateSheet", map[string]any{
+ "parent": project,
+ "sheet": map[string]any{"content": base64.StdEncoding.EncodeToString([]byte("SELECT 1;"))},
+ }, http.StatusOK),
+ },
+ {
+ name: "mcp/audited refused by the clamp in the handler", method: v1connect.SQLServiceQueryProcedure, mcp: true, parent: project,
+ wantRow: true, wantWarning: true,
+ call: func(t *testing.T) {
+ require.NoError(t, ctl.setMCPCapability(ctx, v1pb.MCPSetting_READ_ONLY))
+ defer func() { require.NoError(t, ctl.setMCPCapability(ctx, v1pb.MCPSetting_READ_WRITE)) }()
+ write := queryDatabaseOnSession(ctx, t, clamp.session, clamp.name, "INSERT INTO employee VALUES (2, 'agent')")
+ require.True(t, write.isError, write.text)
+ require.Contains(t, write.text, "READ_ONLY")
+ },
+ },
+ {
+ name: "public/audited refused by the SQL Editor access check", method: v1connect.SQLServiceQueryProcedure,
+ member: true, parent: project,
+ wantRow: true, wantWarning: true,
+ call: func(t *testing.T) {
+ // projectDeveloper carries bb.databases.get, so the ACL admits
+ // the call, and not bb.sql.select, so the handler's own check
+ // refuses it.
+ restore := grantMemberProjectRole(t, "roles/projectDeveloper")
+ defer restore()
+ resp, err := memberSQL.Query(ctx, connect.NewRequest(&v1pb.QueryRequest{
+ Name: clamp.database, Statement: "SELECT * FROM employee;", Limit: 1,
+ }))
+ // Query reports this refusal inside its response: the RPC
+ // answers OK and the row's status stays empty, so severity is
+ // the only field that can carry the denial to the audit log.
+ require.NoError(t, err)
+ require.Len(t, resp.Msg.Results, 1)
+ require.Equal(t, []string{"bb.sql.select"},
+ resp.Msg.Results[0].GetPermissionDenied().GetRequiredPermissions())
+ },
+ checkRow: func(t *testing.T, row *v1pb.AuditLog) {
+ require.Nil(t, row.Status, "the refusal never reaches the RPC status")
+ },
+ },
+ {
+ name: "mcp/audited refused by the gate", method: v1connect.UserServiceCreateUserProcedure, mcp: true, parent: workspace,
+ wantWarning: true,
+ call: mcpCall(adminSession, "UserService/CreateUser", map[string]any{
+ "user": map[string]any{"email": "[email protected]", "title": "sneaky", "password": memberPassword},
+ }, http.StatusForbidden),
+ },
+ {
+ name: "mcp/audited refused by ACL", method: v1connect.PlanServiceCreatePlanProcedure, member: true, mcp: true, parent: project,
+ wantWarning: true,
+ call: mcpCall(memberSession, "PlanService/CreatePlan", map[string]any{
+ "parent": project,
+ "plan": map[string]any{"title": "not mine to make"},
+ }, http.StatusForbidden),
+ },
+ {
+ name: "mcp/unaudited refused by the gate", method: v1connect.UserServiceListUsersProcedure, mcp: true, parent: workspace,
+ wantWarning: true,
+ call: mcpCall(adminSession, "UserService/ListUsers", map[string]any{}, http.StatusForbidden),
+ },
+ {
+ name: "mcp/unaudited refused in handler", method: v1connect.IssueServiceSearchIssuesProcedure, member: true, mcp: true, parent: workspace,
+ wantWarning: true,
+ call: mcpCall(memberSession, "IssueService/SearchIssues", map[string]any{"parent": project}, http.StatusForbidden),
+ },
+ {
+ name: "mcp/unaudited ok", method: v1connect.WorkspaceServiceListWorkspacesProcedure, mcp: true, parent: workspace,
+ call: mcpCall(adminSession, "WorkspaceService/ListWorkspaces", map[string]any{}, http.StatusOK),
+ },
+ {
+ name: "mcp/audited validate-only ok", method: v1connect.DatabaseGroupServiceCreateDatabaseGroupProcedure, mcp: true, parent: project,
+ call: mcpCall(adminSession, "DatabaseGroupService/CreateDatabaseGroup", map[string]any{
+ "parent": project,
+ "databaseGroupId": "sinks-mcp",
+ "databaseGroup": map[string]any{"title": "sinks-mcp", "databaseExpr": map[string]any{"expression": "true"}},
+ "validateOnly": true,
+ }, http.StatusOK),
+ },
+ {
+ name: "mcp/audited validate-only refused by the gate", method: v1connect.InstanceServiceUpdateDataSourceProcedure, mcp: true, parent: workspace,
+ wantWarning: true,
+ checkLine: func(t *testing.T, line map[string]any) {
+ require.Contains(t, lineText(line, "request"), `"validateOnly":true`,
+ "the skip keys on the outcome, not on the flag")
+ },
+ call: mcpCall(adminSession, "InstanceService/UpdateDataSource", map[string]any{
+ "name": "instances/sinks",
+ "dataSource": map[string]any{"id": "admin", "host": "attacker.example.com"},
+ "updateMask": "host",
+ "validateOnly": true,
+ }, http.StatusForbidden),
+ },
+ }
+
+ for _, stdout := range []bool{true, false} {
+ ctl.profile.RuntimeEnableAuditLogStdout.Store(stdout)
+ for _, p := range probes {
+ t.Run(fmt.Sprintf("stdout=%t/%s", stdout, p.name), func(t *testing.T) {
+ user := adminUser
+ if p.member {
+ user = memberUser
+ }
+ before := len(auditSinkRows(ctx, t, ctl, p, user))
+ linesBefore := len(lines())
+
+ p.call(t)
+
+ rows := auditSinkRows(ctx, t, ctl, p, user)
+ var got []map[string]any
+ for _, line := range lines()[linesBefore:] {
+ if line["method"] == p.method && line["user"] == user && lineFlag(line, "mcp") == p.mcp &&
+ (p.match == nil || p.match(lineText(line, "request"))) {
+ got = append(got, line)
+ }
+ }
+
+ severity := v1pb.AuditLog_INFO
+ if p.wantWarning {
+ severity = v1pb.AuditLog_WARNING
+ }
+ if p.wantRow {
+ require.Len(t, rows, before+1, "the call must be stored once")
+ // Newest first.
+ require.Equal(t, severity, rows[0].Severity)
+ require.True(t, strings.HasPrefix(rows[0].Name, p.parent+"/auditLogs/"), rows[0].Name)
+ if p.checkRow != nil {
+ p.checkRow(t, rows[0])
+ }
+ } else {
+ require.Len(t, rows, before, "the call must not be stored")
+ }
+ // Stdout carries every stored row and every refusal.
+ wantLine := stdout && (p.wantRow || p.wantWarning)
+ if !wantLine {
+ require.Empty(t, got, "the call must not be streamed")
+ return
+ }
+ require.Len(t, got, 1, "the call must be streamed once")
+ require.Equal(t, p.parent, got[0]["parent"])
+ require.Equal(t, severity.String(), got[0]["severity"])
+ if p.wantRow {
+ require.Equal(t, rows[0].Request, lineText(got[0], "request"), "one built row feeds both sinks")
+ }
+ if p.checkLine != nil {
+ p.checkLine(t, got[0])
+ }
+ })
+ }
+ }
+}
+
+func lineText(line map[string]any, key string) string {
+ v, ok := line[key].(string)
+ if !ok {
+ return ""
+ }
+ return v
+}
+
+func auditSinkRows(ctx context.Context, t *testing.T, ctl *controller, p auditSinkProbe, user string) []*v1pb.AuditLog {
+ t.Helper()
+ resp, err := ctl.auditLogServiceClient.SearchAuditLogs(ctx, connect.NewRequest(&v1pb.SearchAuditLogsRequest{
+ // Unscoped: a row filed under the wrong parent must fail the probe's
+ // parent assertion, not vanish from the search.
+ Parent: "projects/-",
+ Filter: `method == "` + p.method + `"`,
+ OrderBy: "create_time desc",
+ PageSize: 1000,
+ }))
+ require.NoError(t, err)
+ var rows []*v1pb.AuditLog
+ for _, row := range resp.Msg.AuditLogs {
+ if row.User == user && (row.McpDelegation != nil) == p.mcp && (p.match == nil || p.match(row.Request)) {
+ rows = append(rows, row)
+ }
+ }
+ return rows
+}