Skip to content

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

fix(api): check the create permission on allow_missing updates (T11) (#21284)

Danny Xu477d34ad321b
diff --git a/backend/api/mcp/gen/openapi.yaml b/backend/api/mcp/gen/openapi.yaml
index 812642750f..2598036d87 100644
--- a/backend/api/mcp/gen/openapi.yaml
+++ b/backend/api/mcp/gen/openapi.yaml
@@ -21415,12 +21415,6 @@ components:
title: update_mask
description: The list of fields to update.
$ref: '#/components/schemas/google.protobuf.FieldMask'
- allowMissing:
- type: boolean
- title: allow_missing
- description: |-
- If set to true, and the database is not found, a new database will be created.
- In this situation, `update_mask` is ignored.
title: UpdateDatabaseRequest
additionalProperties: false
bytebase.v1.UpdateEmailRequest:
diff --git a/backend/api/v1/acl.go b/backend/api/v1/acl.go
index cd5d22fef5..45501e27bc 100644
--- a/backend/api/v1/acl.go
+++ b/backend/api/v1/acl.go
@@ -185,10 +185,12 @@ func (in *ACLInterceptor) doACLCheck(ctx context.Context, request any, fullMetho
return err
}
- // Check allow_missing secondary permission if applicable
- // This handles Update methods that can create resources via allow_missing=true
- // When allow_missing is set, we additionally require create permission
- if hasAllowMissingEnabled(request) {
+ // An Update that creates via allow_missing=true also needs the create permission.
+ // IAM only: doIAMPermissionCheck returns true for every other auth method, so
+ // running this on a CUSTOM method would verify nothing while reading as
+ // protection. CUSTOM handlers check for themselves, pinned by
+ // TestAllowMissingCreatePermission.
+ if authContext.AuthMethod == common.AuthMethodIAM && hasAllowMissingEnabled(request) {
// Derive create permission by replacing ".update" with ".create"
// Example: "bb.roles.update" -> "bb.roles.create"
createPerm := strings.Replace(string(authContext.Permission), ".update", ".create", 1)
diff --git a/backend/api/v1/acl_allow_missing_test.go b/backend/api/v1/acl_allow_missing_test.go
new file mode 100644
index 0000000000..81abdb63d1
--- /dev/null
+++ b/backend/api/v1/acl_allow_missing_test.go
@@ -0,0 +1,233 @@
+package v1
+
+import (
+ "fmt"
+ "slices"
+ "strings"
+ "testing"
+
+ "github.com/stretchr/testify/require"
+ "google.golang.org/protobuf/proto"
+ "google.golang.org/protobuf/reflect/protoreflect"
+ "google.golang.org/protobuf/reflect/protoregistry"
+ "google.golang.org/protobuf/types/descriptorpb"
+
+ "github.com/bytebase/bytebase/backend/common/permission"
+ v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"
+)
+
+// An allow_missing Update creates the resource when it is absent, so it needs
+// the create permission too. Two mechanisms supply that check, each failing
+// silently:
+//
+// - The ACL interceptor covers IAM methods, deriving the permission by
+// rewriting ".update" to ".create". That guess can leave the string
+// unchanged (re-checking what was already checked) or invent one no role
+// holds (denying every caller, as the dead flag on UpdateDatabaseCatalog did).
+// - CUSTOM methods it does not cover at all, and a handler that forgets to
+// check leaves nothing to notice — how UpdateGroup shipped an unchecked
+// create path.
+//
+// So each allow_missing RPC is listed with what authorizes its create path.
+// Gaining or losing the flag fails the build.
+var allowMissingCreateChecks = map[string]allowMissingCreateCheck{
+ // Interceptor-enforced: the permission the rewrite must produce. The test
+ // proves it exists and differs from the declared one.
+ "bytebase.v1.InstanceService.UpdateInstance": {createPermission: permission.InstancesCreate},
+ "bytebase.v1.InstanceService.UpdateDataSource": {createPermission: permission.InstancesCreate},
+ "bytebase.v1.RoleService.UpdateRole": {createPermission: permission.RolesCreate},
+ "bytebase.v1.IssueService.UpdateIssue": {createPermission: permission.IssuesCreate},
+ "bytebase.v1.IssueService.UpdateIssueComment": {createPermission: permission.IssueCommentsCreate},
+ "bytebase.v1.ReviewConfigService.UpdateReviewConfig": {createPermission: permission.ReviewConfigsCreate},
+ "bytebase.v1.IdentityProviderService.UpdateIdentityProvider": {createPermission: permission.IdentityProvidersCreate},
+ "bytebase.v1.DatabaseGroupService.UpdateDatabaseGroup": {createPermission: permission.DatabaseGroupsCreate},
+ "bytebase.v1.ProjectService.UpdateProject": {createPermission: permission.ProjectsCreate},
+ "bytebase.v1.ProjectService.UpdateWebhook": {createPermission: permission.ProjectsCreate},
+ // Nested: the flag rides on the sub-request, which the interceptor reads only
+ // because hasAllowMissingEnabled names this type by hand. Proven, not assumed.
+ "bytebase.v1.InstanceService.BatchUpdateInstances": {createPermission: permission.InstancesCreate},
+
+ // Handler-enforced: CUSTOM auth, so the note names the call that checks.
+ "bytebase.v1.OrgPolicyService.UpdatePolicy": {
+ handlerCheck: "org_policy_service.go createPolicyMessage -> checkPolicyPermission(PoliciesCreate, or the MASKING_RULE/MASKING_EXEMPTION variant)",
+ },
+ "bytebase.v1.PlanService.UpdatePlan": {
+ handlerCheck: "plan_service.go UpdatePlan checks permission.PlansCreate before delegating to CreatePlan",
+ },
+ "bytebase.v1.GroupService.UpdateGroup": {
+ handlerCheck: "group_service.go UpdateGroup checks permission.GroupsCreate before delegating to CreateGroup",
+ },
+ "bytebase.v1.UserService.UpdateUser": {
+ handlerCheck: "user_service.go UpdateUser checks permission.UsersCreate before delegating to CreateUser",
+ },
+ "bytebase.v1.SettingService.UpdateSetting": {
+ handlerCheck: "setting_service.go UpdateSetting checks the bb.settings.set family before the existence lookup; a setting has one write permission covering create and update",
+ },
+}
+
+// allowMissingCreateCheck names how one RPC authorizes its create path. Exactly
+// one field is set.
+type allowMissingCreateCheck struct {
+ createPermission string
+ handlerCheck string
+}
+
+// TestAllowMissingCreatePermission fails when an allow_missing create path is
+// authorized by nobody, or by a permission that cannot deny or cannot grant.
+func TestAllowMissingCreatePermission(t *testing.T) {
+ found := allowMissingMethods(t)
+
+ var undeclared []string
+ for name, method := range found {
+ check, ok := allowMissingCreateChecks[name]
+ if !ok {
+ shape := "allow_missing"
+ if method.nested {
+ shape = "a nested allow_missing sub-request, which hasAllowMissingEnabled reads only for the types it names by hand"
+ }
+ undeclared = append(undeclared, fmt.Sprintf("%s takes %s (auth_method=%s, permission=%q)", name, shape, method.authMethod, method.permission))
+ continue
+ }
+
+ if check.handlerCheck != "" {
+ require.Empty(t, check.createPermission, "%s lists both mechanisms; set exactly one", name)
+ require.Equal(t, v1pb.AuthMethod_CUSTOM, method.authMethod,
+ "%s is listed as handler-enforced but is %s-authed, so the interceptor covers it — list its derived create permission instead", name, method.authMethod)
+ continue
+ }
+
+ require.NotEmpty(t, check.createPermission, "%s lists neither mechanism; set exactly one", name)
+ require.Equal(t, v1pb.AuthMethod_IAM, method.authMethod,
+ "%s is listed as interceptor-enforced but is %s-authed; doIAMPermissionCheck returns true for every non-IAM method, so nothing is verified", name, method.authMethod)
+ require.NotEmpty(t, method.permission,
+ "%s declares no permission, so the interceptor derives the empty string and denies every caller", name)
+
+ derived := strings.Replace(method.permission, ".update", ".create", 1)
+ require.NotEqual(t, method.permission, derived,
+ "%s declares %q, which the interceptor's .update -> .create rewrite leaves unchanged, so the secondary check re-checks the permission already checked", name, method.permission)
+ require.True(t, permission.Exist(derived),
+ "%s derives %q, which is not in permission.yaml; CheckPermission never matches an unknown string, so allow_missing=true denies every caller", name, derived)
+ require.Equal(t, check.createPermission, derived,
+ "%s derives a different create permission than the one listed here", name)
+
+ requireInterceptorSeesAllowMissing(t, name, method)
+ }
+
+ var stale []string
+ for name := range allowMissingCreateChecks {
+ if _, ok := found[name]; !ok {
+ stale = append(stale, name)
+ }
+ }
+
+ slices.Sort(undeclared)
+ slices.Sort(stale)
+ require.Empty(t, undeclared, "these RPCs take allow_missing but no one has said what authorizes the create path:\n %s", strings.Join(undeclared, "\n "))
+ require.Empty(t, stale, "these listed RPCs no longer take allow_missing; drop the entries:\n %s", strings.Join(stale, "\n "))
+}
+
+type allowMissingMethod struct {
+ authMethod v1pb.AuthMethod
+ permission string
+ // nested: the flag is on a sub-request, the BatchUpdateInstances shape.
+ nested bool
+ input protoreflect.FullName
+}
+
+// allowMissingMethods returns every bytebase.v1 RPC carrying allow_missing,
+// keyed by full method name.
+func allowMissingMethods(t *testing.T) map[string]allowMissingMethod {
+ t.Helper()
+ methods := map[string]allowMissingMethod{}
+ protoregistry.GlobalFiles.RangeFiles(func(fd protoreflect.FileDescriptor) bool {
+ if fd.Package() != "bytebase.v1" {
+ return true
+ }
+ services := fd.Services()
+ for i := range services.Len() {
+ sd := services.Get(i)
+ descriptors := sd.Methods()
+ for j := range descriptors.Len() {
+ md := descriptors.Get(j)
+ direct, nested := allowMissingShape(md.Input())
+ if !direct && !nested {
+ continue
+ }
+ method := allowMissingMethod{nested: !direct, input: md.Input().FullName()}
+ if options, ok := md.Options().(*descriptorpb.MethodOptions); ok {
+ if p, ok := proto.GetExtension(options, v1pb.E_Permission).(string); ok {
+ method.permission = p
+ }
+ if a, ok := proto.GetExtension(options, v1pb.E_AuthMethod).(v1pb.AuthMethod); ok {
+ method.authMethod = a
+ }
+ }
+ methods[string(sd.FullName())+"."+string(md.Name())] = method
+ }
+ }
+ return true
+ })
+ require.NotEmpty(t, methods, "no allow_missing RPCs found; the descriptor walk is broken, not the API")
+ return methods
+}
+
+// requireInterceptorSeesAllowMissing sets allow_missing on the real request and
+// asserts hasAllowMissingEnabled reads it. This is the point for nested shapes:
+// the interceptor reaches a sub-request only via its hand-written type switch,
+// so a batch RPC missing from that switch reports false here.
+func requireInterceptorSeesAllowMissing(t *testing.T, name string, method allowMissingMethod) {
+ t.Helper()
+
+ mt, err := protoregistry.GlobalTypes.FindMessageByName(method.input)
+ require.NoError(t, err, "%s: cannot resolve request type %s", name, method.input)
+ msg := mt.New()
+
+ if method.nested {
+ fd := nestedAllowMissingField(msg.Descriptor())
+ require.NotNil(t, fd, "%s: no nested allow_missing field", name)
+ sub := msg.Mutable(fd)
+ if fd.IsList() {
+ sub = sub.List().AppendMutable()
+ }
+ subMsg := sub.Message()
+ subMsg.Set(subMsg.Descriptor().Fields().ByName("allow_missing"), protoreflect.ValueOfBool(true))
+ } else {
+ msg.Set(msg.Descriptor().Fields().ByName("allow_missing"), protoreflect.ValueOfBool(true))
+ }
+
+ require.True(t, hasAllowMissingEnabled(msg.Interface()),
+ "%s sets allow_missing but hasAllowMissingEnabled does not see it, so the create permission is never checked; add the request type to its type switch", name)
+}
+
+// nestedAllowMissingField returns the sub-request field carrying allow_missing,
+// or nil. allowMissingShape defers to it so the two cannot disagree.
+func nestedAllowMissingField(md protoreflect.MessageDescriptor) protoreflect.FieldDescriptor {
+ fields := md.Fields()
+ for i := range fields.Len() {
+ fd := fields.Get(i)
+ if fd.Kind() != protoreflect.MessageKind || fd.IsMap() {
+ continue
+ }
+ if hasAllowMissingField(fd.Message()) {
+ return fd
+ }
+ }
+ return nil
+}
+
+// allowMissingShape reports how a request carries allow_missing: directly, or on
+// a sub-request one level down. Listing both is what surfaces a new batch RPC
+// the interceptor's type switch does not name.
+func allowMissingShape(md protoreflect.MessageDescriptor) (direct, nested bool) {
+ if hasAllowMissingField(md) {
+ return true, false
+ }
+ return false, nestedAllowMissingField(md) != nil
+}
+
+// hasAllowMissingField mirrors hasAllowMissingEnabled's lookup: a bool named
+// exactly allow_missing.
+func hasAllowMissingField(md protoreflect.MessageDescriptor) bool {
+ fd := md.Fields().ByName("allow_missing")
+ return fd != nil && fd.Kind() == protoreflect.BoolKind
+}
diff --git a/backend/api/v1/group_service.go b/backend/api/v1/group_service.go
index 636d51f8e2..3ba324d244 100644
--- a/backend/api/v1/group_service.go
+++ b/backend/api/v1/group_service.go
@@ -163,14 +163,27 @@ func (s *GroupService) UpdateGroup(ctx context.Context, req *connect.Request[v1p
if err != nil {
return nil, connect.NewError(connect.CodeInternal, err)
}
+ user, ok := GetUserFromContext(ctx)
+ if !ok {
+ return nil, connect.NewError(connect.CodeInternal, errors.New("user not found"))
+ }
+
if group == nil {
if req.Msg.AllowMissing {
groupEmail, err := common.GetGroupEmail(req.Msg.Group.Name)
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, err)
}
- // Permission check is now handled by the ACL interceptor
- // which verifies both bb.groups.update and bb.groups.create
+ // Checked here, not by the ACL interceptor: UpdateGroup is CUSTOM-authed,
+ // and the CreateGroup call below is in-process, so neither path reaches
+ // the interceptor. No group exists yet, so no owner bypass applies.
+ ok, err := s.iamManager.CheckPermission(ctx, permission.GroupsCreate, user, common.GetWorkspaceIDFromContext(ctx))
+ if err != nil {
+ return nil, connect.NewError(connect.CodeInternal, errors.Wrap(err, "failed to check permission"))
+ }
+ if !ok {
+ return nil, connect.NewError(connect.CodePermissionDenied, errors.Errorf("user does not have permission %q", permission.GroupsCreate))
+ }
return s.CreateGroup(ctx, connect.NewRequest(&v1pb.CreateGroupRequest{
Group: req.Msg.Group,
GroupEmail: groupEmail,
@@ -182,10 +195,6 @@ func (s *GroupService) UpdateGroup(ctx context.Context, req *connect.Request[v1p
return nil, connect.NewError(connect.CodeFailedPrecondition, errors.Errorf("not support update external group %q", req.Msg.Group.Name))
}
- user, ok := GetUserFromContext(ctx)
- if !ok {
- return nil, connect.NewError(connect.CodeInternal, errors.New("user not found"))
- }
if err := s.checkPermission(ctx, group, user, permission.GroupsUpdate); err != nil {
return nil, err
}
diff --git a/backend/generated-go/v1/database_service.pb.go b/backend/generated-go/v1/database_service.pb.go
index c025b8eb52..379c6f878d 100644
--- a/backend/generated-go/v1/database_service.pb.go
+++ b/backend/generated-go/v1/database_service.pb.go
@@ -864,10 +864,7 @@ type UpdateDatabaseRequest struct {
// Format: instances/{instance}/databases/{database} or projects/{project}/instances/{instance}/databases/{database}
Database *Database `protobuf:"bytes,1,opt,name=database,proto3" json:"database,omitempty"`
// The list of fields to update.
- UpdateMask *fieldmaskpb.FieldMask `protobuf:"bytes,2,opt,name=update_mask,json=updateMask,proto3" json:"update_mask,omitempty"`
- // If set to true, and the database is not found, a new database will be created.
- // In this situation, `update_mask` is ignored.
- AllowMissing bool `protobuf:"varint,3,opt,name=allow_missing,json=allowMissing,proto3" json:"allow_missing,omitempty"`
+ UpdateMask *fieldmaskpb.FieldMask `protobuf:"bytes,2,opt,name=update_mask,json=updateMask,proto3" json:"update_mask,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
@@ -916,13 +913,6 @@ func (x *UpdateDatabaseRequest) GetUpdateMask() *fieldmaskpb.FieldMask {
return nil
}
-func (x *UpdateDatabaseRequest) GetAllowMissing() bool {
- if x != nil {
- return x.AllowMissing
- }
- return false
-}
-
type BatchUpdateDatabasesRequest struct {
state protoimpl.MessageState `protogen:"open.v1"`
// The parent resource shared by all databases being updated.
@@ -5480,12 +5470,11 @@ const file_v1_database_service_proto_rawDesc = "" +
"\border_by\x18\x06 \x01(\tR\aorderBy\"t\n" +
"\x15ListDatabasesResponse\x123\n" +
"\tdatabases\x18\x01 \x03(\v2\x15.bytebase.v1.DatabaseR\tdatabases\x12&\n" +
- "\x0fnext_page_token\x18\x02 \x01(\tR\rnextPageToken\"\xb1\x01\n" +
+ "\x0fnext_page_token\x18\x02 \x01(\tR\rnextPageToken\"\x8c\x01\n" +
"\x15UpdateDatabaseRequest\x126\n" +
"\bdatabase\x18\x01 \x01(\v2\x15.bytebase.v1.DatabaseB\x03\xe0A\x02R\bdatabase\x12;\n" +
"\vupdate_mask\x18\x02 \x01(\v2\x1a.google.protobuf.FieldMaskR\n" +
- "updateMask\x12#\n" +
- "\rallow_missing\x18\x03 \x01(\bR\fallowMissing\"z\n" +
+ "updateMask\"z\n" +
"\x1bBatchUpdateDatabasesRequest\x12\x16\n" +
"\x06parent\x18\x01 \x01(\tR\x06parent\x12C\n" +
"\brequests\x18\x02 \x03(\v2\".bytebase.v1.UpdateDatabaseRequestB\x03\xe0A\x02R\brequests\"S\n" +
diff --git a/backend/generated-go/v1/database_service_equal.pb.go b/backend/generated-go/v1/database_service_equal.pb.go
index 4f003a06a1..9a32cff918 100644
--- a/backend/generated-go/v1/database_service_equal.pb.go
+++ b/backend/generated-go/v1/database_service_equal.pb.go
@@ -127,9 +127,6 @@ func (x *UpdateDatabaseRequest) Equal(y *UpdateDatabaseRequest) bool {
} else if !proto.Equal(x.UpdateMask, y.UpdateMask) {
return false
}
- if x.AllowMissing != y.AllowMissing {
- return false
- }
return true
}
diff --git a/backend/tests/group_allow_missing_test.go b/backend/tests/group_allow_missing_test.go
new file mode 100644
index 0000000000..6b2857d34e
--- /dev/null
+++ b/backend/tests/group_allow_missing_test.go
@@ -0,0 +1,92 @@
+package tests
+
+import (
+ "context"
+ "fmt"
+ "testing"
+
+ "connectrpc.com/connect"
+ "github.com/stretchr/testify/require"
+
+ v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"
+)
+
+// TestUpdateGroupAllowMissingRequiresCreatePermission pins the create check on
+// UpdateGroup's allow_missing path. Neither the ACL interceptor (CUSTOM auth) nor
+// CreateGroup (called in-process) covers it, so for a while a caller with no group
+// permission could create one — and name itself OWNER, which checkPermission honors.
+func TestUpdateGroupAllowMissingRequiresCreatePermission(t *testing.T) {
+ t.Parallel()
+ a := require.New(t)
+ ctx := context.Background()
+ ctl := &controller{}
+ ctx, err := ctl.StartServerWithExternalPg(ctx)
+ a.NoError(err)
+ defer ctl.Close(ctx)
+
+ adminToken := ctl.authInterceptor.token
+ const password = "1024bytebase"
+
+ login := func(email string) string {
+ resp, err := ctl.authServiceClient.Login(ctx, connect.NewRequest(&v1pb.LoginRequest{
+ Email: email,
+ Password: password,
+ }))
+ a.NoError(err)
+ return resp.Msg.Token
+ }
+ createUserWithRole := func(prefix, role string) string {
+ email := fmt.Sprintf("%s-%[email protected]", prefix, generateRandomString("u"))
+ created, err := ctl.userServiceClient.CreateUser(ctx, connect.NewRequest(&v1pb.CreateUserRequest{
+ User: &v1pb.User{Email: email, Password: password, Title: prefix},
+ }))
+ a.NoError(err)
+ _, err = ctl.addMemberToWorkspaceIAM(ctx, created.Msg.Workspace, "user:"+email, role)
+ a.NoError(err)
+ return email
+ }
+
+ // Workspace DBA holds neither bb.groups.create nor bb.groups.update.
+ dbaEmail := createUserWithRole("dba", "roles/workspaceDBA")
+ dbaToken := login(dbaEmail)
+
+ // Fixture check: if this ever passes, the role gained bb.groups.create and the
+ // denial below would prove nothing.
+ ctl.authInterceptor.token = dbaToken
+ _, err = ctl.groupServiceClient.CreateGroup(ctx, connect.NewRequest(&v1pb.CreateGroupRequest{
+ Group: &v1pb.Group{Title: "Front door"},
+ GroupEmail: fmt.Sprintf("front-%[email protected]", generateRandomString("g")),
+ }))
+ a.Error(err)
+ a.Equal(connect.CodePermissionDenied, connect.CodeOf(err), "workspace DBA must not hold bb.groups.create")
+
+ // The regression: no back door to creation either.
+ deniedGroupEmail := fmt.Sprintf("denied-%[email protected]", generateRandomString("g"))
+ deniedGroupName := "groups/" + deniedGroupEmail
+ _, err = ctl.groupServiceClient.UpdateGroup(ctx, connect.NewRequest(&v1pb.UpdateGroupRequest{
+ Group: &v1pb.Group{Name: deniedGroupName, Title: "Back door"},
+ AllowMissing: true,
+ }))
+ a.Error(err)
+ a.Equal(connect.CodePermissionDenied, connect.CodeOf(err), "UpdateGroup(allow_missing) must require bb.groups.create")
+
+ // And nothing was written on the way to the denial.
+ ctl.authInterceptor.token = adminToken
+ _, err = ctl.groupServiceClient.GetGroup(ctx, connect.NewRequest(&v1pb.GetGroupRequest{Name: deniedGroupName}))
+ a.Error(err)
+ a.Equal(connect.CodeNotFound, connect.CodeOf(err), "the denied UpdateGroup must not have created the group")
+
+ // Positive control: Workspace Member holds bb.groups.create, so allow_missing
+ // still creates. Also proves the denial above is the permission, not the
+ // USER_GROUPS license guard, which runs first and would deny both alike.
+ memberEmail := createUserWithRole("member", "roles/workspaceMember")
+ ctl.authInterceptor.token = login(memberEmail)
+
+ allowedGroupEmail := fmt.Sprintf("allowed-%[email protected]", generateRandomString("g"))
+ created, err := ctl.groupServiceClient.UpdateGroup(ctx, connect.NewRequest(&v1pb.UpdateGroupRequest{
+ Group: &v1pb.Group{Name: "groups/" + allowedGroupEmail, Title: "Allowed"},
+ AllowMissing: true,
+ }))
+ a.NoError(err)
+ a.Equal(allowedGroupEmail, created.Msg.Email)
+}
diff --git a/docs/design/v1-api-audit-2026-08.md b/docs/design/v1-api-audit-2026-08.md
index ba497f9e35..cfaa45f75c 100644
--- a/docs/design/v1-api-audit-2026-08.md
+++ b/docs/design/v1-api-audit-2026-08.md
@@ -12,7 +12,6 @@ noted. Fixed findings are removed and listed at the end.
|---|---|---|
| T12 | Anonymous callers can enumerate emails, relay mail, and read your LDAP config | MED |
| T16 | Four `BatchGet` RPCs behave four different ways when an item is missing | MED |
-| T11 | A create-permission check is skipped on `allow_missing` updates | MED |
| T18c | Three smaller ones: broken filter, unpaginated list, half-finished delete | MED |
---
@@ -40,16 +39,6 @@ call was authorized against the workspace. Both are fixed and listed at the end.
generalizes — the next request field that departs from the convention arrives unchecked, silently,
and only a sweep like this one finds it.
-### T11 · A create check is skipped on `allow_missing` updates — MED
-
-`UpdateGroup(allow_missing=true)` creates a group when none exists, but the create-permission check
-is short-circuited for CUSTOM-auth RPCs, so nothing is verified. Harmless today only because every
-member can create groups anyway — but the code comment right above it claims the check happens,
-which is how this survives review.
-
-Same root cause, wider: 15 of the 45 CUSTOM RPCs declare a `permission` annotation that is never
-enforced. It's decorative, and it reads as protection. `acl.go:251-253`, `group_service.go:167-177`
-
---
## The API says OK and does nothing
@@ -142,8 +131,9 @@ constraints.
failure instead of a silent scope change.
2. **Fail closed on auth annotations, and put api-linter in CI.** Reject
`AUTH_METHOD_UNSPECIFIED` at startup; make a `permission` on a CUSTOM RPC either enforced or a
- build error, since 15 are decorative. None of Tier 5 was visible to `buf lint`'s BASIC profile,
- which is why it accumulated.
+ build error, since 16 of the 52 are decorative — `TestAllowMissingCreatePermission`, added with
+ T11, is the descriptor-walking shape to generalize. None of Tier 5 was visible to `buf lint`'s
+ BASIC profile, which is why it accumulated.
---
@@ -155,6 +145,7 @@ constraints.
| T2 (INPUT_ONLY) | Read-path fix |
| T2 `DiffSchema` | `DiffSchema` rejects a changelog target owned by another project before any read, matching how every other second-resource handler closes it. Not the general interceptor change: the resource the caller names must simply belong to the project they were authorized on, which is also the only thing a cross-project diff could have meant. A missing target and a foreign one return the same error, so neither confirms what lives in the other project. Accepted with it: the class stays latent — a future second-resource field still arrives unchecked |
| T19 `UpdateDatabaseCatalog` | The interceptor now reads `catalog.name`, so the permission is checked against the named database's project instead of the workspace — the route resolver already drops the trailing `/catalog`. Strictly additive: workspace holders are unaffected and Project Owner, whose role carries `bb.databaseCatalogs.update`, is no longer denied. Separate and still open: `bb.databaseCatalogs.create` does not exist, so the `allow_missing` secondary check denies every caller. Dead rather than harmful — no UI sets the flag and the RPC is MCP-`EXCLUDED` |
+| T11 | `UpdateGroup(allow_missing=true)` now checks `bb.groups.create` itself, the shape `UpdatePlan` and `UpdateUser` already had. The interceptor never covered it: `doIAMPermissionCheck` returns true for every non-IAM auth method, so the `allow_missing` secondary block evaluated to nothing on a CUSTOM RPC, and the create path calls `CreateGroup` in-process, which bypasses the interceptor anyway — while the comment above it claimed both permissions were verified. The exposure was narrower and differently shaped than first written: Workspace Member does hold `bb.groups.create`, but Workspace DBA and every project role do not, so a DBA-only principal could create a group and name itself OWNER, which `checkPermission` then honors for that group. It stops there — a group confers nothing until someone with IAM-policy rights binds a role to it. The interceptor's block is now gated on `AuthMethod == IAM` so it no longer reads as protection where it verifies nothing (behavior-preserving: it already returned true there). Found tracing the same mechanism, and fixed with it: the `.update` → `.create` string rewrite is unvalidated, and `UpdateDatabase` derived `bb.databases.create`, which does not exist — `CheckPermission` never matches an unknown string, so `allow_missing=true` denied every caller including Workspace Admin, on a flag `database_service.go` never read and the proto documented as working. The field is removed and the proto now says never to add it back, since a database is not independently creatable. `TestAllowMissingCreatePermission` walks the descriptors and makes all four silent failure modes a build failure — an RPC that gains the flag with nothing authorizing its create path, a derived permission that does not exist, a declared permission the rewrite leaves unchanged (`bb.settings.set` is one, and vacuous if it ever went IAM), and a nested `allow_missing` sub-request the interceptor's hand-written type switch does not name, which it proves by building the request and asserting `hasAllowMissingEnabled` reads it. Still open, and the other half of the original finding: 16 of the 52 CUSTOM RPCs declare a `permission` annotation that nothing ties to enforcement, so it remains documentation that reads as protection |
| T5, T6 | [#21143](https://github.com/bytebase/bytebase/pull/21143) — `sheet_blob_ref` gives sheets per-project ownership; `BatchCreateRevisions` rejects foreign-project provenance without echoing the hash |
| T7 | [#21102](https://github.com/bytebase/bytebase/pull/21102) — every `CheckRelease` target validated against the parent project before any schema read (its error codes still leak existence — T18c-iii) |
| T8 `CreateWorksheet` | [#21169](https://github.com/bytebase/bytebase/pull/21169) — `CreateSavedQuery` is now IAM-enforced; Workspace Member holds no saved-query permission, and new queries start creator-private |
diff --git a/frontend/src/types/proto-es/v1/database_service_pb.d.ts b/frontend/src/types/proto-es/v1/database_service_pb.d.ts
index 4ccbc85469..b6d073bfb5 100644
--- a/frontend/src/types/proto-es/v1/database_service_pb.d.ts
+++ b/frontend/src/types/proto-es/v1/database_service_pb.d.ts
@@ -224,14 +224,6 @@ export declare type UpdateDatabaseRequest = Message<"bytebase.v1.UpdateDatabaseR
* @generated from field: google.protobuf.FieldMask update_mask = 2;
*/
updateMask?: FieldMask | undefined;
-
- /**
- * If set to true, and the database is not found, a new database will be created.
- * In this situation, `update_mask` is ignored.
- *
- * @generated from field: bool allow_missing = 3;
- */
- allowMissing: boolean;
};
/**
diff --git a/frontend/src/types/proto-es/v1/database_service_pb.js b/frontend/src/types/proto-es/v1/database_service_pb.js
index 39e51b7e76..68dfdeacd2 100644
--- a/frontend/src/types/proto-es/v1/database_service_pb.js
+++ b/frontend/src/types/proto-es/v1/database_service_pb.js
@@ -16,7 +16,7 @@ import { file_v1_instance_service } from "./instance_service_pb";
* Describes the file v1/database_service.proto.
*/
export const file_v1_database_service = /*@__PURE__*/
- fileDesc("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", [file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_field_mask, file_google_protobuf_timestamp, file_v1_annotation, file_v1_common, file_v1_instance_service]);
+ fileDesc("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", [file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_field_mask, file_google_protobuf_timestamp, file_v1_annotation, file_v1_common, file_v1_instance_service]);
/**
* Describes the message bytebase.v1.GetDatabaseRequest.
diff --git a/proto/gen/grpc-doc/openapi.yaml b/proto/gen/grpc-doc/openapi.yaml
index 24be63e57f..7cbab8b4c8 100644
--- a/proto/gen/grpc-doc/openapi.yaml
+++ b/proto/gen/grpc-doc/openapi.yaml
@@ -2511,14 +2511,6 @@ paths:
`INVALID_ARGUMENT` error if any path is unmappable.
schema:
type: string
- - name: allowMissing
- in: query
- description: |-
- If set to true, and the database is not found, a new database will be created.
- In this situation, `update_mask` is ignored.
- schema:
- type: boolean
- title: allow_missing
requestBody:
description: |-
The database to update.
@@ -7629,14 +7621,6 @@ paths:
`INVALID_ARGUMENT` error if any path is unmappable.
schema:
type: string
- - name: allowMissing
- in: query
- description: |-
- If set to true, and the database is not found, a new database will be created.
- In this situation, `update_mask` is ignored.
- schema:
- type: boolean
- title: allow_missing
requestBody:
description: |-
The database to update.
@@ -32727,12 +32711,6 @@ components:
title: update_mask
description: The list of fields to update.
$ref: '#/components/schemas/google.protobuf.FieldMask'
- allowMissing:
- type: boolean
- title: allow_missing
- description: |-
- If set to true, and the database is not found, a new database will be created.
- In this situation, `update_mask` is ignored.
title: UpdateDatabaseRequest
required:
- database
diff --git a/proto/gen/grpc-doc/v1/README.md b/proto/gen/grpc-doc/v1/README.md
index 4a16e89ebb..cba8c27e0b 100644
--- a/proto/gen/grpc-doc/v1/README.md
+++ b/proto/gen/grpc-doc/v1/README.md
@@ -8726,7 +8726,6 @@ TessellationConfig defines tessellation parameters for spatial indexes.
The database&#39;s `name` field is used to identify the database to update. Format: instances/{instance}/databases/{database} or projects/{project}/instances/{instance}/databases/{database} |
| update_mask | [google.protobuf.FieldMask](#google-protobuf-FieldMask) | | The list of fields to update. |
-| allow_missing | [bool](#bool) | | If set to true, and the database is not found, a new database will be created. In this situation, `update_mask` is ignored. |
diff --git a/proto/gen/grpc-doc/v1/index.html b/proto/gen/grpc-doc/v1/index.html
index dbc8f0fc5f..5324b966b3 100644
--- a/proto/gen/grpc-doc/v1/index.html
+++ b/proto/gen/grpc-doc/v1/index.html
@@ -24909,14 +24909,6 @@ Format: instances/{instance}/databases/{database} or projects/{project}/instance
<td><p>The list of fields to update. </p></td>
</tr>
- <tr>
- <td>allow_missing</td>
- <td><a href="#bool">bool</a></td>
- <td></td>
- <td><p>If set to true, and the database is not found, a new database will be created.
-In this situation, `update_mask` is ignored. </p></td>
- </tr>
-
</tbody>
</table>
diff --git a/proto/v1/v1/database_service.proto b/proto/v1/v1/database_service.proto
index e241aec177..de73e0977d 100644
--- a/proto/v1/v1/database_service.proto
+++ b/proto/v1/v1/database_service.proto
@@ -340,9 +340,8 @@ message UpdateDatabaseRequest {
// The list of fields to update.
google.protobuf.FieldMask update_mask = 2;
- // If set to true, and the database is not found, a new database will be created.
- // In this situation, `update_mask` is ignored.
- bool allow_missing = 3;
+ // Never add allow_missing: a database is not independently creatable, it
+ // appears when its instance is synced, so the flag has nothing to create.
}
message BatchUpdateDatabasesRequest {