Skip to content

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

fix: resolve valid workspace by iam (#21183)

ecmadaofe809a6cfb7a
diff --git a/backend/store/workspace.go b/backend/store/workspace.go
index 496393c885..9801da654f 100644
--- a/backend/store/workspace.go
+++ b/backend/store/workspace.go
@@ -4,6 +4,8 @@ import (
"context"
"database/sql"
"fmt"
+ "log/slog"
+ "time"
"github.com/pkg/errors"
colorpb "google.golang.org/genproto/googleapis/type/color"
@@ -12,6 +14,7 @@ import (
"google.golang.org/protobuf/proto"
"github.com/bytebase/bytebase/backend/common"
+ "github.com/bytebase/bytebase/backend/common/log"
"github.com/bytebase/bytebase/backend/common/qb"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
)
@@ -277,7 +280,7 @@ func (s *Store) FindWorkspace(ctx context.Context, find *FindWorkspaceMessage) (
}
// ListWorkspacesByEmail finds all workspaces where the given email is a member
-// in the workspace IAM policy bindings, either directly or via a group.
+// in a currently valid workspace IAM policy binding, directly or via a group.
// Returns workspaces sorted by name.
func (s *Store) ListWorkspacesByEmail(ctx context.Context, find *FindWorkspaceMessage) ([]*WorkspaceMessage, error) {
memberName := common.FormatUserEmail(find.Email)
@@ -301,16 +304,16 @@ func (s *Store) ListWorkspacesByEmail(ctx context.Context, find *FindWorkspaceMe
}
q := qb.Q().Space(`
- SELECT DISTINCT w.resource_id, w.payload, w.created_at
+ SELECT DISTINCT w.resource_id, w.payload, w.created_at, binding
FROM workspace w
JOIN policy p ON p.workspace = w.resource_id
+ CROSS JOIN LATERAL jsonb_array_elements(p.payload->'bindings') AS binding
WHERE p.resource_type = ?
AND p.type = ?
AND w.deleted = FALSE
AND EXISTS (
SELECT 1
- FROM jsonb_array_elements(p.payload->'bindings') AS binding,
- jsonb_array_elements_text(binding->'members') AS member
+ FROM jsonb_array_elements_text(binding->'members') AS member
WHERE ?
)
`, storepb.Policy_WORKSPACE.String(), storepb.Policy_IAM.String(), memberFilter)
@@ -330,19 +333,35 @@ func (s *Store) ListWorkspacesByEmail(ctx context.Context, find *FindWorkspaceMe
}
defer rows.Close()
+ requestTime := time.Now()
+ seen := map[string]bool{}
var workspaces []*WorkspaceMessage
for rows.Next() {
var ws WorkspaceMessage
var payloadBytes []byte
+ var bindingBytes []byte
var createdAt any
- if err := rows.Scan(&ws.ResourceID, &payloadBytes, &createdAt); err != nil {
+ if err := rows.Scan(&ws.ResourceID, &payloadBytes, &createdAt, &bindingBytes); err != nil {
return nil, errors.Wrap(err, "failed to scan workspace")
}
+ binding := &storepb.Binding{}
+ if err := common.ProtojsonUnmarshaler.Unmarshal(bindingBytes, binding); err != nil {
+ return nil, errors.Wrap(err, "failed to unmarshal workspace IAM binding")
+ }
+ valid, err := common.EvalBindingCondition(binding.Condition.GetExpression(), requestTime)
+ if err != nil {
+ slog.Error("failed to eval workspace IAM binding condition", slog.String("expression", binding.Condition.GetExpression()), log.BBError(err))
+ continue
+ }
+ if !valid || seen[ws.ResourceID] {
+ continue
+ }
payload := &storepb.WorkspacePayload{}
if err := common.ProtojsonUnmarshaler.Unmarshal(payloadBytes, payload); err != nil {
return nil, errors.Wrap(err, "failed to unmarshal workspace payload")
}
ws.Payload = payload
+ seen[ws.ResourceID] = true
workspaces = append(workspaces, &ws)
}
if err := rows.Err(); err != nil {
diff --git a/backend/store/workspace_test.go b/backend/store/workspace_test.go
new file mode 100644
index 0000000000..84eb1ea03f
--- /dev/null
+++ b/backend/store/workspace_test.go
@@ -0,0 +1,126 @@
+package store_test
+
+import (
+ "context"
+ "fmt"
+ "slices"
+ "testing"
+
+ "github.com/stretchr/testify/require"
+ "google.golang.org/genproto/googleapis/type/expr"
+ "google.golang.org/protobuf/encoding/protojson"
+
+ "github.com/bytebase/bytebase/backend/common"
+ "github.com/bytebase/bytebase/backend/common/testcontainer"
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/migrator"
+ "github.com/bytebase/bytebase/backend/store"
+
+ _ "github.com/bytebase/bytebase/backend/plugin/db/pg"
+)
+
+func TestListWorkspacesByEmailEvaluatesBindingConditions(t *testing.T) {
+ ctx := context.Background()
+ container := testcontainer.GetTestPgContainer(ctx, t)
+ t.Cleanup(func() { container.Close(ctx) })
+ db := container.GetDB()
+ require.NoError(t, migrator.MigrateSchema(ctx, db))
+
+ pgURL := fmt.Sprintf(
+ "host=%s port=%s user=postgres password=root-password database=postgres",
+ container.GetHost(), container.GetPort(),
+ )
+ stores, err := store.New(ctx, pgURL, false)
+ require.NoError(t, err)
+ t.Cleanup(func() { require.NoError(t, stores.Close()) })
+
+ const email = "[email protected]"
+ activeCondition := `request.time < timestamp("2099-01-01T00:00:00Z")`
+ expiredCondition := `request.time < timestamp("2000-01-01T00:00:00Z")`
+ tests := []struct {
+ workspace string
+ memberType string
+ condition string
+ want bool
+ }{
+ {workspace: "active-direct", memberType: "direct", condition: activeCondition, want: true},
+ {workspace: "expired-direct", memberType: "direct", condition: expiredCondition},
+ {workspace: "active-group", memberType: "group", condition: activeCondition, want: true},
+ {workspace: "expired-group", memberType: "group", condition: expiredCondition},
+ {workspace: "active-all-users", memberType: "allUsers", condition: activeCondition, want: true},
+ {workspace: "expired-all-users", memberType: "allUsers", condition: expiredCondition},
+ }
+
+ var want []string
+ for _, test := range tests {
+ _, err := db.ExecContext(ctx, `INSERT INTO workspace (resource_id) VALUES ($1)`, test.workspace)
+ require.NoError(t, err)
+
+ member := common.FormatUserEmail(email)
+ switch test.memberType {
+ case "group":
+ group, err := stores.CreateGroup(ctx, &store.GroupMessage{
+ Workspace: test.workspace,
+ Email: test.workspace + "@example.com",
+ Title: test.workspace,
+ Payload: &storepb.GroupPayload{Members: []*storepb.GroupMember{{
+ Member: common.FormatUserEmail(email),
+ Role: storepb.GroupMember_MEMBER,
+ }}},
+ })
+ require.NoError(t, err)
+ member = common.FormatGroupEmail(group.Email)
+ case "allUsers":
+ member = common.AllUsers
+ default:
+ require.Equal(t, "direct", test.memberType)
+ }
+
+ payload, err := protojson.Marshal(&storepb.IamPolicy{Bindings: []*storepb.Binding{{
+ Role: "roles/workspaceMember",
+ Members: []string{member},
+ Condition: &expr.Expr{Expression: test.condition},
+ }}})
+ require.NoError(t, err)
+ _, err = stores.CreatePolicy(ctx, &store.PolicyMessage{
+ Workspace: test.workspace,
+ Resource: common.FormatWorkspace(test.workspace),
+ ResourceType: storepb.Policy_WORKSPACE,
+ Payload: string(payload),
+ Type: storepb.Policy_IAM,
+ InheritFromParent: false,
+ Enforce: true,
+ })
+ require.NoError(t, err)
+ if test.want {
+ want = append(want, test.workspace)
+ }
+ }
+
+ workspaces, err := stores.ListWorkspacesByEmail(ctx, &store.FindWorkspaceMessage{
+ Email: email,
+ IncludeAllUser: true,
+ })
+ require.NoError(t, err)
+ got := make([]string, 0, len(workspaces))
+ for _, workspace := range workspaces {
+ got = append(got, workspace.ResourceID)
+ }
+ slices.Sort(got)
+ slices.Sort(want)
+ require.Equal(t, want, got)
+
+ for _, test := range tests {
+ workspace, err := stores.FindWorkspace(ctx, &store.FindWorkspaceMessage{
+ WorkspaceID: &test.workspace,
+ Email: email,
+ IncludeAllUser: true,
+ })
+ require.NoError(t, err)
+ if test.want {
+ require.NotNil(t, workspace)
+ } else {
+ require.Nil(t, workspace)
+ }
+ }
+}