This is an automated email from the ASF dual-hosted git repository. LinkinStars pushed a commit to branch fix/2.0.4/user in repository https://gitbox.apache.org/repos/asf/answer.git
commit 3e4a72cd29025cd68b890c47f29aceffa0c9ae1d Author: LinkinStars <[email protected]> AuthorDate: Fri Oct 30 18:45:40 2026 +0800 fix(security): restrict access to non-public revisions --- cmd/wire_gen.go | 2 +- internal/service/activity/activity.go | 49 ++++++ .../service/activity/revision_visibility_test.go | 167 +++++++++++++++++++++ 3 files changed, 217 insertions(+), 1 deletion(-) diff --git a/cmd/wire_gen.go b/cmd/wire_gen.go index 92b9cd1b..2ad50bfd 100644 --- a/cmd/wire_gen.go +++ b/cmd/wire_gen.go @@ -265,7 +265,7 @@ func initApplication(debug bool, serverConf *conf.Server, dbConf *data.Database, activityActivityRepo := activity.NewActivityRepo(dataData, configService) activityCommon := activity_common2.NewActivityCommon(activityRepo, service) commentCommonService := comment_common.NewCommentCommonService(commentCommonRepo) - activityService := activity2.NewActivityService(activityActivityRepo, userCommon, activityCommon, tagCommonService, objService, commentCommonService, revisionService, metaCommonService, configService) + activityService := activity2.NewActivityService(activityActivityRepo, userCommon, activityCommon, tagCommonService, objService, commentCommonService, revisionService, rankService, metaCommonService, configService) activityController := controller.NewActivityController(activityService) roleController := controller_admin.NewRoleController(roleService) pluginConfigRepo := plugin_config.NewPluginConfigRepo(dataData) diff --git a/internal/service/activity/activity.go b/internal/service/activity/activity.go index deae9b9f..458f0204 100644 --- a/internal/service/activity/activity.go +++ b/internal/service/activity/activity.go @@ -36,6 +36,8 @@ import ( "github.com/apache/answer/internal/service/comment_common" "github.com/apache/answer/internal/service/config" "github.com/apache/answer/internal/service/object_info" + "github.com/apache/answer/internal/service/permission" + "github.com/apache/answer/internal/service/rank" "github.com/apache/answer/internal/service/revision_common" "github.com/apache/answer/internal/service/tag_common" usercommon "github.com/apache/answer/internal/service/user_common" @@ -51,6 +53,10 @@ type ActivityRepo interface { GetObjectAllActivity(ctx context.Context, objectID string, showVote bool) (activityList []*entity.Activity, err error) } +type timelineRevisionPermissionChecker interface { + CheckOperationPermissions(ctx context.Context, userID string, actions []string) (can []bool, err error) +} + // ActivityService activity service type ActivityService struct { activityRepo ActivityRepo @@ -60,6 +66,7 @@ type ActivityService struct { objectInfoService *object_info.ObjService commentCommonService *comment_common.CommentCommonService revisionService *revision_common.RevisionService + rankService timelineRevisionPermissionChecker metaService *metacommon.MetaCommonService configService *config.ConfigService } @@ -73,6 +80,7 @@ func NewActivityService( objectInfoService *object_info.ObjService, commentCommonService *comment_common.CommentCommonService, revisionService *revision_common.RevisionService, + rankService *rank.RankService, metaService *metacommon.MetaCommonService, configService *config.ConfigService, ) *ActivityService { @@ -84,6 +92,7 @@ func NewActivityService( tagCommonService: tagCommonService, commentCommonService: commentCommonService, revisionService: revisionService, + rankService: rankService, metaService: metaService, configService: configService, } @@ -282,9 +291,49 @@ func (as *ActivityService) ensureTimelineRevisionVisible(ctx context.Context, re if err != nil { return err } + if err := as.ensureTimelineRevisionStatusVisible(ctx, revisionInfo, userID); err != nil { + return err + } return as.ensureTimelineObjectVisible(ctx, revisionInfo.ObjectID, userID, isAdminModerator) } +func (as *ActivityService) ensureTimelineRevisionStatusVisible(ctx context.Context, revisionInfo *entity.Revision, + userID string) error { + if isTimelineRevisionPublic(revisionInfo.Status) { + return nil + } + + reviewPermission, ok := timelineRevisionReviewPermission(revisionInfo.ObjectType) + if !ok { + return errors.NotFound(reason.ObjectNotFound) + } + canReview, err := as.rankService.CheckOperationPermissions(ctx, userID, []string{reviewPermission}) + if err != nil { + return err + } + if len(canReview) == 0 || !canReview[0] { + return errors.NotFound(reason.ObjectNotFound) + } + return nil +} + +func isTimelineRevisionPublic(status int) bool { + return status == entity.RevisionNormalStatus || status == entity.RevisionReviewPassStatus +} + +func timelineRevisionReviewPermission(objectType int) (string, bool) { + switch objectType { + case constant.ObjectTypeStrMapping[constant.QuestionObjectType]: + return permission.QuestionAudit, true + case constant.ObjectTypeStrMapping[constant.AnswerObjectType]: + return permission.AnswerAudit, true + case constant.ObjectTypeStrMapping[constant.TagObjectType]: + return permission.TagAudit, true + default: + return "", false + } +} + func (as *ActivityService) ensureTimelineObjectVisible(ctx context.Context, objectID, userID string, isAdminModerator bool) error { objInfo, err := as.objectInfoService.GetInfo(ctx, objectID) diff --git a/internal/service/activity/revision_visibility_test.go b/internal/service/activity/revision_visibility_test.go new file mode 100644 index 00000000..eccafd48 --- /dev/null +++ b/internal/service/activity/revision_visibility_test.go @@ -0,0 +1,167 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package activity + +import ( + "context" + "errors" + "testing" + + "github.com/apache/answer/internal/base/constant" + "github.com/apache/answer/internal/entity" + "github.com/apache/answer/internal/service/permission" +) + +type timelineRevisionPermissionCheckerStub struct { + can []bool + err error + calls int + userID string + actions []string +} + +func (s *timelineRevisionPermissionCheckerStub) CheckOperationPermissions(_ context.Context, userID string, actions []string) ([]bool, error) { + s.calls++ + s.userID = userID + s.actions = actions + return s.can, s.err +} + +func TestIsTimelineRevisionPublic(t *testing.T) { + tests := []struct { + name string + status int + want bool + }{ + {name: "normal", status: entity.RevisionNormalStatus, want: true}, + {name: "approved", status: entity.RevisionReviewPassStatus, want: true}, + {name: "pending", status: entity.RevisionUnreviewedStatus, want: false}, + {name: "rejected", status: entity.RevisionReviewRejectStatus, want: false}, + {name: "unknown status", status: 99, want: false}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := isTimelineRevisionPublic(tt.status); got != tt.want { + t.Errorf("isTimelineRevisionPublic(%d) = %v, want %v", tt.status, got, tt.want) + } + }) + } +} + +func TestTimelineRevisionReviewPermission(t *testing.T) { + tests := []struct { + name string + objectType int + want string + wantOK bool + }{ + {name: "question", objectType: constant.ObjectTypeStrMapping[constant.QuestionObjectType], want: permission.QuestionAudit, wantOK: true}, + {name: "answer", objectType: constant.ObjectTypeStrMapping[constant.AnswerObjectType], want: permission.AnswerAudit, wantOK: true}, + {name: "tag", objectType: constant.ObjectTypeStrMapping[constant.TagObjectType], want: permission.TagAudit, wantOK: true}, + {name: "unsupported object", objectType: constant.ObjectTypeStrMapping[constant.CommentObjectType], wantOK: false}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, ok := timelineRevisionReviewPermission(tt.objectType) + if got != tt.want || ok != tt.wantOK { + t.Errorf("timelineRevisionReviewPermission(%d) = (%q, %v), want (%q, %v)", tt.objectType, got, ok, tt.want, tt.wantOK) + } + }) + } +} + +func TestEnsureTimelineRevisionStatusVisible(t *testing.T) { + tests := []struct { + name string + revision *entity.Revision + checker *timelineRevisionPermissionCheckerStub + wantErr bool + wantCalls int + wantAction string + }{ + { + name: "normal revision is public", + revision: &entity.Revision{Status: entity.RevisionNormalStatus}, + checker: &timelineRevisionPermissionCheckerStub{}, + wantCalls: 0, + }, + { + name: "pending question is denied to a normal user", + revision: &entity.Revision{Status: entity.RevisionUnreviewedStatus, ObjectType: constant.ObjectTypeStrMapping[constant.QuestionObjectType]}, + checker: &timelineRevisionPermissionCheckerStub{can: []bool{false}}, + wantErr: true, + wantCalls: 1, + wantAction: permission.QuestionAudit, + }, + { + name: "rejected answer is denied to a normal user", + revision: &entity.Revision{Status: entity.RevisionReviewRejectStatus, ObjectType: constant.ObjectTypeStrMapping[constant.AnswerObjectType]}, + checker: &timelineRevisionPermissionCheckerStub{can: []bool{false}}, + wantErr: true, + wantCalls: 1, + wantAction: permission.AnswerAudit, + }, + { + name: "authorized tag reviewer can access pending revision", + revision: &entity.Revision{Status: entity.RevisionUnreviewedStatus, ObjectType: constant.ObjectTypeStrMapping[constant.TagObjectType]}, + checker: &timelineRevisionPermissionCheckerStub{can: []bool{true}}, + wantCalls: 1, + wantAction: permission.TagAudit, + }, + { + name: "unknown revision type fails closed", + revision: &entity.Revision{Status: entity.RevisionUnreviewedStatus, ObjectType: constant.ObjectTypeStrMapping[constant.CommentObjectType]}, + checker: &timelineRevisionPermissionCheckerStub{can: []bool{true}}, + wantErr: true, + wantCalls: 0, + }, + { + name: "permission lookup failure is returned", + revision: &entity.Revision{Status: entity.RevisionUnreviewedStatus, ObjectType: constant.ObjectTypeStrMapping[constant.QuestionObjectType]}, + checker: &timelineRevisionPermissionCheckerStub{err: errors.New("permission lookup failed")}, + wantErr: true, + wantCalls: 1, + wantAction: permission.QuestionAudit, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + service := &ActivityService{rankService: tt.checker} + err := service.ensureTimelineRevisionStatusVisible(context.Background(), tt.revision, "reader") + if (err != nil) != tt.wantErr { + t.Fatalf("ensureTimelineRevisionStatusVisible error = %v, wantErr %v", err, tt.wantErr) + } + if tt.checker.calls != tt.wantCalls { + t.Fatalf("permission checks = %d, want %d", tt.checker.calls, tt.wantCalls) + } + if tt.wantAction != "" { + if tt.checker.userID != "reader" { + t.Errorf("permission user ID = %q, want reader", tt.checker.userID) + } + if len(tt.checker.actions) != 1 || tt.checker.actions[0] != tt.wantAction { + t.Errorf("permission actions = %v, want [%s]", tt.checker.actions, tt.wantAction) + } + } + }) + } +}
