Skip to content

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

fix: add project-level ACL validation to prevent cross-project access (BYT-8272) (#17904)

boojacka087c51e612b
diff --git a/backend/api/v1/database_service.go b/backend/api/v1/database_service.go
index 3bc1eb292f..3028700ed1 100644
--- a/backend/api/v1/database_service.go
+++ b/backend/api/v1/database_service.go
@@ -73,7 +73,17 @@ func (s *DatabaseService) BatchGetDatabases(ctx context.Context, req *connect.Re
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("user not found"))
}
- // TODO(steven): Filter out the databases based on `req.Msg.parent`.
+ // Parse parent to extract project ID filter if specified.
+ var projectIDFilter *string
+ if strings.HasPrefix(req.Msg.Parent, common.ProjectNamePrefix) {
+ projectID, err := common.GetProjectID(req.Msg.Parent)
+ if err != nil {
+ return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("invalid parent %q", req.Msg.Parent))
+ }
+ projectIDFilter = &projectID
+ }
+ // For instances/{instance} or "-" (wildcard), no project filter is applied.
+
databases := make([]*v1pb.Database, 0, len(req.Msg.Names))
for _, name := range req.Msg.Names {
databaseMessage, err := getDatabaseMessage(ctx, s.store, name)
@@ -81,7 +91,12 @@ func (s *DatabaseService) BatchGetDatabases(ctx context.Context, req *connect.Re
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get database %q with error: %v", name, err.Error()))
}
if databaseMessage.Deleted {
- // Ignore no deleted database.
+ // Ignore deleted database.
+ continue
+ }
+ // If parent specifies a project, validate database belongs to that project.
+ if projectIDFilter != nil && databaseMessage.ProjectID != *projectIDFilter {
+ // Ignore database not in the specified project.
continue
}
ok, err := s.iamManager.CheckPermission(ctx, iam.PermissionDatabasesGet, user, databaseMessage.ProjectID)
diff --git a/backend/api/v1/plan_service.go b/backend/api/v1/plan_service.go
index b26540248f..ce63e169c9 100644
--- a/backend/api/v1/plan_service.go
+++ b/backend/api/v1/plan_service.go
@@ -1045,7 +1045,7 @@ func (s *PlanService) BatchCancelPlanCheckRuns(ctx context.Context, request *con
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("plan check runs cannot be empty"))
}
- projectID, _, err := common.GetProjectIDPlanID(req.Parent)
+ projectID, planID, err := common.GetProjectIDPlanID(req.Parent)
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, err)
}
@@ -1075,6 +1075,13 @@ func (s *PlanService) BatchCancelPlanCheckRuns(ctx context.Context, request *con
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to list plan check runs, error: %v", err))
}
+ // Validate that all plan check runs belong to the plan specified in the parent.
+ for _, planCheckRun := range planCheckRuns {
+ if planCheckRun.PlanUID != planID {
+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("plan check run %d not found in plan %d", planCheckRun.UID, planID))
+ }
+ }
+
// Check if any of the given plan check runs are not running.
for _, planCheckRun := range planCheckRuns {
switch planCheckRun.Status {
diff --git a/backend/api/v1/revision_service.go b/backend/api/v1/revision_service.go
index bd641fa993..2cd1ea5309 100644
--- a/backend/api/v1/revision_service.go
+++ b/backend/api/v1/revision_service.go
@@ -144,7 +144,7 @@ func (s *RevisionService) CreateRevision(
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("failed to get taskRun from %q", request.Revision.TaskRun))
}
- taskRun, err := s.store.GetTaskRun(ctx, taskRunID)
+ taskRun, err := s.store.GetTaskRunByUID(ctx, taskRunID)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get taskRun"))
}
diff --git a/backend/api/v1/rollout_service.go b/backend/api/v1/rollout_service.go
index 232dd85264..0e32de6599 100644
--- a/backend/api/v1/rollout_service.go
+++ b/backend/api/v1/rollout_service.go
@@ -306,7 +306,7 @@ func (s *RolloutService) ListTaskRuns(ctx context.Context, req *connect.Request[
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get rollout, error: %v", err))
}
if pipeline == nil {
- return nil, connect.NewError(connect.CodeInternal, errors.Errorf("pipeline %d not found in project %s", rolloutID, projectID))
+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("pipeline %d not found in project %s", rolloutID, projectID))
}
taskRuns, err := s.store.ListTaskRunsV2(ctx, &store.FindTaskRunMessage{
@@ -343,15 +343,18 @@ func (s *RolloutService) GetTaskRun(ctx context.Context, req *connect.Request[v1
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get rollout, error: %v", err))
}
if pipeline == nil {
- return nil, connect.NewError(connect.CodeInternal, errors.Errorf("pipeline %d not found in project %s", rolloutID, projectID))
+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("pipeline %d not found in project %s", rolloutID, projectID))
}
- taskRun, err := s.store.GetTaskRun(ctx, taskRunUID)
+ taskRun, err := s.store.GetTaskRunV1(ctx, &store.FindTaskRunMessage{
+ UID: &taskRunUID,
+ PipelineUID: &pipeline.ID,
+ })
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get task run, error: %v", err))
}
if taskRun == nil {
- return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("task run %d not found", taskRunUID))
+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("task run %d not found in pipeline %d", taskRunUID, pipeline.ID))
}
taskRunV1, err := convertToTaskRun(ctx, s.store, s.stateCfg, taskRun)
diff --git a/backend/store/task_run.go b/backend/store/task_run.go
index 1603a3af53..3ba62f6ebd 100644
--- a/backend/store/task_run.go
+++ b/backend/store/task_run.go
@@ -45,17 +45,6 @@ type FindTaskRunMessage struct {
Status *[]storepb.TaskRun_Status
}
-// TaskRunFind is the API message for finding task runs.
-type TaskRunFind struct {
- // Related fields
- TaskID *int
- Environment *string
- PipelineID *int
-
- // Domain specific fields
- StatusList *[]storepb.TaskRun_Status
-}
-
// TaskRunStatusPatch is the API message for patching a task run.
type TaskRunStatusPatch struct {
ID int
@@ -188,21 +177,26 @@ func (s *Store) ListTaskRunsV2(ctx context.Context, find *FindTaskRunMessage) ([
return taskRuns, nil
}
-// GetTaskRun gets a task run by uid.
-func (s *Store) GetTaskRun(ctx context.Context, uid int) (*TaskRunMessage, error) {
- taskRuns, err := s.ListTaskRunsV2(ctx, &FindTaskRunMessage{UID: &uid})
+// GetTaskRunV1 gets a task run.
+func (s *Store) GetTaskRunV1(ctx context.Context, find *FindTaskRunMessage) (*TaskRunMessage, error) {
+ taskRuns, err := s.ListTaskRunsV2(ctx, find)
if err != nil {
return nil, err
}
if len(taskRuns) == 0 {
- return nil, errors.Errorf("task run not found: %d", uid)
+ return nil, errors.Errorf("task run not found")
}
if len(taskRuns) > 1 {
- return nil, errors.Errorf("found multiple task runs for uid: %d", uid)
+ return nil, errors.Errorf("expected to get one task run, but got %d", len(taskRuns))
}
return taskRuns[0], nil
}
+// GetTaskRunByUID gets a task run by uid.
+func (s *Store) GetTaskRunByUID(ctx context.Context, uid int) (*TaskRunMessage, error) {
+ return s.GetTaskRunV1(ctx, &FindTaskRunMessage{UID: &uid})
+}
+
// UpdateTaskRunStatus updates task run status.
func (s *Store) UpdateTaskRunStatus(ctx context.Context, patch *TaskRunStatusPatch) (*TaskRunMessage, error) {
tx, err := s.GetDB().BeginTx(ctx, nil)
@@ -463,101 +457,6 @@ func (*Store) patchTaskRunStatusImpl(ctx context.Context, txn *sql.Tx, patch *Ta
return &taskRun, nil
}
-// ListTaskRun returns a list of taskRuns.
-func (s *Store) ListTaskRun(ctx context.Context, find *TaskRunFind) ([]*TaskRunMessage, error) {
- tx, err := s.GetDB().BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
- if err != nil {
- return nil, err
- }
- defer tx.Rollback()
-
- list, err := s.findTaskRunImpl(ctx, tx, find)
- if err != nil {
- return nil, err
- }
-
- if err := tx.Commit(); err != nil {
- return nil, err
- }
-
- return list, nil
-}
-
-func (*Store) findTaskRunImpl(ctx context.Context, txn *sql.Tx, find *TaskRunFind) ([]*TaskRunMessage, error) {
- q := qb.Q().Space(`
- SELECT
- task_run.id,
- task_run.creator_id,
- task_run.created_at,
- task_run.updated_at,
- task_run.task_id,
- task_run.status,
- task_run.code,
- task_run.result,
- task.pipeline_id,
- task.environment
- FROM task_run
- JOIN task ON task.id = task_run.task_id
- WHERE TRUE
- `)
-
- if v := find.TaskID; v != nil {
- q.And("task_run.task_id = ?", *v)
- }
- if v := find.Environment; v != nil {
- q.And("task.environment = ?", *v)
- }
- if v := find.PipelineID; v != nil {
- q.And("task.pipeline_id = ?", *v)
- }
- if v := find.StatusList; v != nil {
- var statusValues []any
- for _, status := range *v {
- statusValues = append(statusValues, status)
- }
- q.And("task_run.status = ANY(?)", statusValues)
- }
-
- q.Space("ORDER BY task_run.id ASC")
-
- query, args, err := q.ToSQL()
- if err != nil {
- return nil, errors.Wrapf(err, "failed to build sql")
- }
-
- rows, err := txn.QueryContext(ctx, query, args...)
- if err != nil {
- return nil, err
- }
- defer rows.Close()
-
- var taskRuns []*TaskRunMessage
- for rows.Next() {
- var taskRun TaskRunMessage
- if err := rows.Scan(
- &taskRun.ID,
- &taskRun.CreatorID,
- &taskRun.CreatedAt,
- &taskRun.UpdatedAt,
- &taskRun.TaskUID,
- &taskRun.Status,
- &taskRun.Code,
- &taskRun.Result,
- &taskRun.PipelineUID,
- &taskRun.Environment,
- ); err != nil {
- return nil, err
- }
-
- taskRuns = append(taskRuns, &taskRun)
- }
- if err := rows.Err(); err != nil {
- return nil, err
- }
-
- return taskRuns, nil
-}
-
// BatchCancelTaskRuns updates the status of taskRuns to CANCELED.
func (s *Store) BatchCancelTaskRuns(ctx context.Context, taskRunIDs []int) error {
if len(taskRunIDs) == 0 {