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)
+                               }
+                       }
+               })
+       }
+}

Reply via email to