Skip to content

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

fix: harden ACL error handling (#21098)

p0ny586ef200baf8
diff --git a/backend/api/v1/acl.go b/backend/api/v1/acl.go
index 5fb53054d4..cc17d961f4 100644
--- a/backend/api/v1/acl.go
+++ b/backend/api/v1/acl.go
@@ -2,7 +2,6 @@ package v1
import (
"context"
- "log/slog"
"regexp"
"strings"
@@ -16,7 +15,6 @@ import (
"github.com/bytebase/bytebase/backend/api/auth"
"github.com/bytebase/bytebase/backend/common"
- "github.com/bytebase/bytebase/backend/common/log"
"github.com/bytebase/bytebase/backend/common/permission"
"github.com/bytebase/bytebase/backend/component/config"
"github.com/bytebase/bytebase/backend/component/iam"
@@ -118,29 +116,11 @@ func hasAllowMissingEnabled(request any) bool {
}
func (in *ACLInterceptor) doACLCheck(ctx context.Context, request any, fullMethod string) error {
- defer func() {
- if r := recover(); r != nil {
- perr, ok := r.(error)
- if !ok {
- perr = errors.Errorf("%v", r)
- }
- slog.Error("iam check PANIC RECOVER", log.BBError(perr), log.BBStack("panic-stack"))
- }
- }()
-
authContextAny := ctx.Value(common.AuthContextKey)
authContext, ok := authContextAny.(*common.AuthContext)
if !ok {
return connect.NewError(connect.CodeInternal, errors.New("auth context not found"))
}
- resources, err := populateRawResources(ctx, in.store, request, fullMethod)
- if err != nil {
- if common.ErrorCode(err) == common.NotFound {
- return connect.NewError(connect.CodeNotFound, err)
- }
- return connect.NewError(connect.CodeInternal, errors.Errorf("failed to populate raw resources %s", err))
- }
- authContext.Resources = resources
authContext.Permission = getPermissionForRequest(request, authContext.Permission)
if auth.IsAuthenticationSkipped(fullMethod, authContext) {
@@ -160,10 +140,16 @@ func (in *ACLInterceptor) doACLCheck(ctx context.Context, request any, fullMetho
if workspaceID == "" {
return connect.NewError(connect.CodeUnauthenticated, errors.Errorf("empty workspace id"))
}
+ resources, err := populateRawResources(ctx, in.store, request, fullMethod)
+ if err != nil {
+ return resourceResolutionConnectError(err)
+ }
+ authContext.Resources = resources
// Workspace isolation: verify all resources belong to the caller's workspace.
- // Instance and database ownership is already validated in populateRawResources
- // (via workspace-filtered store lookups). Here we validate workspace and project resources.
+ // Project, instance, and database ownership is already validated in
+ // populateRawResources via workspace-filtered store lookups. Here we validate
+ // workspace resources.
// Runs after authentication so unauthenticated requests get 401 first,
// preventing resource existence probing.
for _, resource := range authContext.Resources {
@@ -172,14 +158,6 @@ func (in *ACLInterceptor) doACLCheck(ctx context.Context, request any, fullMetho
if resource.ID != workspaceID {
return connect.NewError(connect.CodePermissionDenied, errors.Errorf("workspace mismatch"))
}
- case common.ResourceTypeProject:
- project, err := in.store.GetProject(ctx, &store.FindProjectMessage{Workspace: workspaceID, ResourceID: &resource.ID})
- if err != nil {
- return connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get project"))
- }
- if project == nil || project.Workspace != workspaceID {
- return connect.NewError(connect.CodeNotFound, errors.Errorf("project %q not found", resource.ID))
- }
default:
}
}
@@ -234,6 +212,14 @@ func (in *ACLInterceptor) doACLCheck(ctx context.Context, request any, fullMetho
return nil
}
+func resourceResolutionConnectError(err error) error {
+ var connectErr *connect.Error
+ if errors.As(err, &connectErr) {
+ return err
+ }
+ return connect.NewError(connect.CodeInternal, errors.Wrap(err, "failed to populate raw resources"))
+}
+
func getPermissionForRequest(request any, defaultPermission permission.Permission) permission.Permission {
if r, ok := request.(*v1pb.ListInstanceDatabaseRequest); ok && r.GetInstance() != nil {
return permission.InstancesCreate
@@ -383,11 +369,22 @@ func resolveWorkspaceResource(_ context.Context, _ *store.Store, parts []string)
return &common.Resource{Type: common.ResourceTypeWorkspace, ID: workspaceID}, nil
}
-func resolveProjectResource(_ context.Context, _ *store.Store, parts []string) (*common.Resource, error) {
+func resolveProjectResource(ctx context.Context, stores *store.Store, parts []string) (*common.Resource, error) {
projectID, err := requiredResourceIdentifier(parts, 1, projectCollection)
if err != nil {
return nil, err
}
+ workspaceID := common.GetWorkspaceIDFromContext(ctx)
+ project, err := stores.GetProject(ctx, &store.FindProjectMessage{
+ Workspace: workspaceID,
+ ResourceID: &projectID,
+ })
+ if err != nil {
+ return nil, connect.NewError(connect.CodeInternal, errors.Wrap(err, "failed to get project"))
+ }
+ if project == nil || project.Workspace != workspaceID {
+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("project %q not found", projectID))
+ }
return &common.Resource{Type: common.ResourceTypeProject, ID: projectID}, nil
}
@@ -430,10 +427,10 @@ func resolveProjectDatabaseResource(ctx context.Context, stores *store.Store, pa
ShowDeleted: true,
})
if err != nil {
- return nil, errors.Wrapf(err, "failed to get database")
+ return nil, connect.NewError(connect.CodeInternal, errors.Wrap(err, "failed to get database"))
}
if database == nil {
- return nil, common.Errorf(common.NotFound, "database %q not found", strings.Join(parts[:6], "/"))
+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("database %q not found", strings.Join(parts[:6], "/")))
}
return &common.Resource{Type: common.ResourceTypeProject, ID: projectID}, nil
}
@@ -450,10 +447,10 @@ func resolveWorkspaceInstanceResource(ctx context.Context, stores *store.Store,
ResourceID: &instanceID,
})
if err != nil {
- return nil, errors.Wrapf(err, "failed to get instance")
+ return nil, connect.NewError(connect.CodeInternal, errors.Wrap(err, "failed to get instance"))
}
- if instance == nil {
- return nil, common.Errorf(common.NotFound, "instance %q not found", strings.Join(parts[:2], "/"))
+ if instance == nil || instance.Workspace != workspaceID {
+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("instance %q not found", strings.Join(parts[:2], "/")))
}
return &common.Resource{Type: common.ResourceTypeWorkspace, ID: workspaceID}, nil
}
@@ -474,10 +471,10 @@ func resolveWorkspaceDatabaseResource(ctx context.Context, stores *store.Store,
ResourceID: &instanceID,
})
if err != nil {
- return nil, errors.Wrapf(err, "failed to get instance")
+ return nil, connect.NewError(connect.CodeInternal, errors.Wrap(err, "failed to get instance"))
}
- if instance == nil {
- return nil, errors.Errorf("instance %q not found", instanceID)
+ if instance == nil || instance.Workspace != workspaceID {
+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("instance %q not found", instanceID))
}
database, err := stores.GetDatabase(ctx, &store.FindDatabaseMessage{
Workspace: workspaceID,
@@ -486,17 +483,17 @@ func resolveWorkspaceDatabaseResource(ctx context.Context, stores *store.Store,
ShowDeleted: true,
})
if err != nil {
- return nil, errors.Wrapf(err, "failed to get database")
+ return nil, connect.NewError(connect.CodeInternal, errors.Wrap(err, "failed to get database"))
}
if database == nil {
- return nil, common.Errorf(common.NotFound, "database %q not found", strings.Join(parts[:4], "/"))
+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("database %q not found", strings.Join(parts[:4], "/")))
}
return &common.Resource{Type: common.ResourceTypeProject, ID: database.ProjectID}, nil
}
func requiredResourceIdentifier(parts []string, index int, collection string) (string, error) {
if len(parts) <= index || parts[index] == "" {
- return "", errors.Errorf("invalid %s resource %q", collection, strings.Join(parts, "/"))
+ return "", connect.NewError(connect.CodeInvalidArgument, errors.Errorf("invalid %s resource %q", collection, strings.Join(parts, "/")))
}
return parts[index], nil
}
@@ -529,16 +526,17 @@ func populateRawResources(ctx context.Context, stores *store.Store, request any,
}
func getProjectScopedInstance(ctx context.Context, stores *store.Store, projectID, instanceID string) (*store.InstanceMessage, error) {
+ workspaceID := common.GetWorkspaceIDFromContext(ctx)
instance, err := stores.GetInstance(ctx, &store.FindInstanceMessage{
- Workspace: common.GetWorkspaceIDFromContext(ctx),
+ Workspace: workspaceID,
ProjectID: &projectID,
ResourceID: &instanceID,
})
if err != nil {
- return nil, errors.Wrapf(err, "failed to get instance")
+ return nil, connect.NewError(connect.CodeInternal, errors.Wrap(err, "failed to get instance"))
}
- if instance == nil {
- return nil, common.Errorf(common.NotFound, "instance %q not found", common.FormatProjectInstance(projectID, instanceID))
+ if instance == nil || instance.Workspace != workspaceID {
+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("instance %q not found", common.FormatProjectInstance(projectID, instanceID)))
}
return instance, nil
}
@@ -546,13 +544,13 @@ func getProjectScopedInstance(ctx context.Context, stores *store.Store, projectI
func getResourceFromRequest(ctx context.Context, request any, method string) ([]string, error) {
pm, ok := request.(proto.Message)
if !ok {
- return nil, errors.Errorf("invalid request for method %q", method)
+ return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("invalid request for method %q", method))
}
mr := pm.ProtoReflect()
methodTokens := strings.Split(method, "/")
if len(methodTokens) != 3 {
- return nil, errors.Errorf("invalid method %q", method)
+ return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("invalid method %q", method))
}
shortMethod := methodTokens[2]
@@ -615,7 +613,7 @@ func getResourceFromRequest(ctx context.Context, request any, method string) ([]
if hasPath(r.GetUpdateMask(), "project") {
projectID, err := common.GetProjectID(r.GetDatabase().GetProject())
if err != nil {
- return nil, errors.Wrapf(err, "failed to get projectID from %q", r.GetDatabase().GetProject())
+ return nil, connect.NewError(connect.CodeInvalidArgument, errors.Wrapf(err, "failed to get projectID from %q", r.GetDatabase().GetProject()))
}
// Allow to transfer databases to the default project.
if common.IsDefaultProject(common.GetWorkspaceIDFromContext(ctx), projectID) {
diff --git a/backend/api/v1/acl_test.go b/backend/api/v1/acl_test.go
index 068fb02484..6efe58b180 100644
--- a/backend/api/v1/acl_test.go
+++ b/backend/api/v1/acl_test.go
@@ -2,16 +2,105 @@ package v1
import (
"context"
+ "errors"
"testing"
+ "connectrpc.com/connect"
"github.com/stretchr/testify/require"
"google.golang.org/protobuf/types/known/fieldmaskpb"
"github.com/bytebase/bytebase/backend/common"
"github.com/bytebase/bytebase/backend/common/permission"
v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"
+ "github.com/bytebase/bytebase/backend/generated-go/v1/v1connect"
+ "github.com/bytebase/bytebase/backend/store"
)
+func TestResourceResolutionConnectError(t *testing.T) {
+ t.Run("preserves connect error", func(t *testing.T) {
+ want := connect.NewError(connect.CodeNotFound, errors.New("missing resource"))
+ require.Same(t, want, resourceResolutionConnectError(want))
+ })
+
+ t.Run("converts unknown error", func(t *testing.T) {
+ err := resourceResolutionConnectError(errors.New("store unavailable"))
+ require.Equal(t, connect.CodeInternal, connect.CodeOf(err))
+ require.ErrorContains(t, err, "failed to populate raw resources: store unavailable")
+ })
+}
+
+func TestACLCheckResourceResolutionStatus(t *testing.T) {
+ ctx, stores, _, _, _, _ := setupWorkspaceInstanceDescendantServiceTest(t)
+ interceptor := NewACLInterceptor(stores, "", nil, nil)
+
+ for _, test := range []struct {
+ name string
+ request *v1pb.GetDatabaseRequest
+ want connect.Code
+ }{
+ {
+ name: "missing workspace database parent instance",
+ request: &v1pb.GetDatabaseRequest{Name: common.FormatDatabase("missing", "app")},
+ want: connect.CodeNotFound,
+ },
+ {
+ name: "malformed workspace database name",
+ request: &v1pb.GetDatabaseRequest{Name: "instances//databases/app"},
+ want: connect.CodeInvalidArgument,
+ },
+ } {
+ t.Run(test.name, func(t *testing.T) {
+ err := interceptor.doACLCheck(authenticatedACLContext(ctx), test.request, v1connect.DatabaseServiceGetDatabaseProcedure)
+ require.Equal(t, test.want, connect.CodeOf(err))
+ })
+ }
+}
+
+func TestACLCheckAuthenticatesBeforeResolvingResources(t *testing.T) {
+ ctx, stores, _, _, _, _ := setupWorkspaceInstanceDescendantServiceTest(t)
+ interceptor := NewACLInterceptor(stores, "", nil, nil)
+
+ err := interceptor.doACLCheck(
+ unauthenticatedACLContext(ctx),
+ &v1pb.GetDatabaseRequest{Name: common.FormatDatabase("missing", "app")},
+ v1connect.DatabaseServiceGetDatabaseProcedure,
+ )
+ require.Equal(t, connect.CodeUnauthenticated, connect.CodeOf(err))
+}
+
+func TestACLCheckPanicPreventsRequestAdmission(t *testing.T) {
+ ctx := authenticatedACLContext(context.WithValue(context.Background(), common.WorkspaceIDContextKey, "default"))
+ interceptor := NewACLInterceptor(nil, "", nil, nil)
+ aclCheckReturnedNil := false
+
+ panicked := false
+ func() {
+ defer func() {
+ panicked = recover() != nil
+ }()
+ if err := interceptor.doACLCheck(
+ ctx,
+ &v1pb.GetDatabaseRequest{Name: common.FormatDatabase("instance", "app")},
+ v1connect.DatabaseServiceGetDatabaseProcedure,
+ ); err == nil {
+ aclCheckReturnedNil = true
+ }
+ }()
+
+ require.True(t, panicked, "the outer Connect recovery adapter must receive ACL panics")
+ require.False(t, aclCheckReturnedNil, "a recovered ACL panic must not admit the request")
+}
+
+func authenticatedACLContext(ctx context.Context) context.Context {
+ ctx = context.WithValue(ctx, common.AuthContextKey, &common.AuthContext{AuthMethod: common.AuthMethodCustom})
+ return context.WithValue(ctx, common.UserContextKey, &store.UserMessage{Email: "[email protected]"})
+}
+
+func unauthenticatedACLContext(ctx context.Context) context.Context {
+ ctx = context.WithValue(ctx, common.AuthContextKey, &common.AuthContext{AuthMethod: common.AuthMethodCustom})
+ return context.WithValue(ctx, common.UserContextKey, (*store.UserMessage)(nil))
+}
+
func TestGetResourceRoute(t *testing.T) {
tests := []struct {
name string
@@ -136,12 +225,14 @@ func TestResolveRawResource(t *testing.T) {
t.Run("rejects project instance in another project", func(t *testing.T) {
resource, err := resolveRawResource(ctx, stores, common.FormatProjectInstance("project-b", instanceID)+"/roles/role-a")
require.Error(t, err)
+ require.Equal(t, connect.CodeNotFound, connect.CodeOf(err))
require.Nil(t, resource)
})
t.Run("rejects missing project database", func(t *testing.T) {
resource, err := resolveRawResource(ctx, stores, common.FormatProjectDatabase("project-a", instanceID, "missing")+"/schema")
require.Error(t, err)
+ require.Equal(t, connect.CodeNotFound, connect.CodeOf(err))
require.Nil(t, resource)
})
@@ -156,6 +247,7 @@ func TestResolveRawResource(t *testing.T) {
} {
resource, err := resolveRawResource(ctx, nil, name)
require.Error(t, err, name)
+ require.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err), name)
require.Nil(t, resource, name)
}
})
diff --git a/backend/server/grpc_routes.go b/backend/server/grpc_routes.go
index e51b00498d..4293b7ada2 100644
--- a/backend/server/grpc_routes.go
+++ b/backend/server/grpc_routes.go
@@ -128,20 +128,20 @@ func configureGrpcRouters(
stack := stacktrace.TakeStacktrace(20 /* n */, 5 /* skip */)
// keep a multiline stack
slog.Error("v1 server panic error", "method", s.Procedure, log.BBError(errors.Errorf("error: %v\n%s", p, stack)))
- return connect.NewError(connect.CodeInternal, errors.Errorf("error: %v\n%s", p, stack))
+ return connect.NewError(connect.CodeInternal, errors.New("internal error"))
}
// Create validation interceptor.
validateInterceptor := validate.NewInterceptor()
handlerOpts := connect.WithHandlerOptions(
+ connect.WithRecover(onPanic),
connect.WithInterceptors(
validateInterceptor,
auth.New(stores, secret, licenseService, bus, profile),
apiv1.NewACLInterceptor(stores, secret, iamManager, profile),
apiv1.NewAuditInterceptor(stores, secret, profile),
),
- connect.WithRecover(onPanic),
)
connectHandlers := make(map[string]http.Handler)