This is an automated email from the ASF dual-hosted git repository.

LinkinStars pushed a commit to branch fix/2.0.3/user
in repository https://gitbox.apache.org/repos/asf/answer.git

commit 41a9d887d9361c8b4b70c50abfbb516ec09fe918
Author: LinkinStars <[email protected]>
AuthorDate: Tue Aug 25 16:36:04 2026 +0800

    fix(security): restrict similar question visibility
---
 internal/controller/question_controller.go         | 12 +++-
 internal/service/content/question_service.go       | 16 ++++-
 .../content/question_service_visibility_test.go    | 75 ++++++++++++++++++++++
 3 files changed, 101 insertions(+), 2 deletions(-)

diff --git a/internal/controller/question_controller.go 
b/internal/controller/question_controller.go
index 66d7b221..8294cdcb 100644
--- a/internal/controller/question_controller.go
+++ b/internal/controller/question_controller.go
@@ -832,7 +832,17 @@ func (qc *QuestionController) UpdateQuestionInviteUser(ctx 
*gin.Context) {
 // @Router /answer/api/v1/question/similar [get]
 func (qc *QuestionController) GetSimilarQuestions(ctx *gin.Context) {
        title := ctx.Query("title")
-       resp, err := qc.questionService.GetQuestionsByTitle(ctx, title)
+       userID := middleware.GetLoginUserIDFromContext(ctx)
+       canReopen, err := qc.rankService.CheckOperationPermission(ctx, userID, 
permission.QuestionReopen, "")
+       if err != nil {
+               handler.HandleResponse(ctx, err, nil)
+               return
+       }
+       per := schema.QuestionPermission{
+               IsAdminModerator: middleware.GetUserIsAdminModerator(ctx),
+               CanReopen:        canReopen,
+       }
+       resp, err := qc.questionService.GetQuestionsByTitle(ctx, title, userID, 
per)
        handler.HandleResponse(ctx, err, resp)
 }
 
diff --git a/internal/service/content/question_service.go 
b/internal/service/content/question_service.go
index 82d6e1e0..ced0e010 100644
--- a/internal/service/content/question_service.go
+++ b/internal/service/content/question_service.go
@@ -1385,7 +1385,7 @@ func (qs *QuestionService) SearchUserTopList(ctx 
context.Context, userName strin
 }
 
 // GetQuestionsByTitle get questions by title
-func (qs *QuestionService) GetQuestionsByTitle(ctx context.Context, title 
string) (
+func (qs *QuestionService) GetQuestionsByTitle(ctx context.Context, title, 
userID string, per schema.QuestionPermission) (
        resp []*schema.QuestionBaseInfo, err error) {
        resp = make([]*schema.QuestionBaseInfo, 0)
        if len(title) == 0 {
@@ -1428,6 +1428,9 @@ func (qs *QuestionService) GetQuestionsByTitle(ctx 
context.Context, title string
                }
        }
        for _, question := range questions {
+               if !canViewSimilarQuestion(question, userID, per) {
+                       continue
+               }
                item := &schema.QuestionBaseInfo{}
                item.ID = question.ID
                item.Title = question.Title
@@ -1448,6 +1451,17 @@ func (qs *QuestionService) GetQuestionsByTitle(ctx 
context.Context, title string
        return resp, nil
 }
 
+func canViewSimilarQuestion(question *entity.Question, userID string, per 
schema.QuestionPermission) bool {
+       if question == nil || question.Status == entity.QuestionStatusDeleted {
+               return false
+       }
+       return checkQuestionVisibility(&schema.QuestionInfoResp{
+               UserID: question.UserID,
+               Status: question.Status,
+               Show:   question.Show,
+       }, userID, per) == nil
+}
+
 // SimilarQuestion
 func (qs *QuestionService) SimilarQuestion(ctx context.Context, questionID 
string, loginUserID string) ([]*schema.QuestionPageResp, int64, error) {
        question, err := qs.questioncommon.Info(ctx, questionID, loginUserID)
diff --git a/internal/service/content/question_service_visibility_test.go 
b/internal/service/content/question_service_visibility_test.go
index 9e10b47b..5cfeb5b7 100644
--- a/internal/service/content/question_service_visibility_test.go
+++ b/internal/service/content/question_service_visibility_test.go
@@ -20,12 +20,87 @@
 package content
 
 import (
+       "context"
        "testing"
 
+       "github.com/apache/answer/internal/base/data"
        "github.com/apache/answer/internal/entity"
        "github.com/apache/answer/internal/schema"
 )
 
+func TestCanViewSimilarQuestionWithSQLite(t *testing.T) {
+       ctx := context.Background()
+       db, err := data.NewDB(false, &data.Database{Driver: "sqlite", 
Connection: ":memory:"})
+       if err != nil {
+               t.Fatalf("create SQLite database: %v", err)
+       }
+       t.Cleanup(func() { _ = db.Close() })
+       if err := db.Sync2(new(entity.Question)); err != nil {
+               t.Fatalf("create question table: %v", err)
+       }
+
+       questions := []*entity.Question{
+               {ID: "1", UserID: "author", Title: "public match", 
OriginalText: "public", ParsedText: "public", Status: 
entity.QuestionStatusAvailable, Show: entity.QuestionShow},
+               {ID: "2", UserID: "author", Title: "pending match", 
OriginalText: "pending", ParsedText: "pending", Status: 
entity.QuestionStatusPending, Show: entity.QuestionShow},
+               {ID: "3", UserID: "author", Title: "hidden match", 
OriginalText: "hidden", ParsedText: "hidden", Status: 
entity.QuestionStatusAvailable, Show: entity.QuestionHide},
+               {ID: "4", UserID: "author", Title: "deleted match", 
OriginalText: "deleted", ParsedText: "deleted", Status: 
entity.QuestionStatusDeleted, Show: entity.QuestionShow},
+               {ID: "5", UserID: "viewer", Title: "own pending match", 
OriginalText: "own pending", ParsedText: "own pending", Status: 
entity.QuestionStatusPending, Show: entity.QuestionShow},
+       }
+       for _, question := range questions {
+               if _, err := db.Context(ctx).Insert(question); err != nil {
+                       t.Fatalf("insert question %s: %v", question.ID, err)
+               }
+       }
+
+       var candidates []*entity.Question
+       if err := db.Context(ctx).Where("title like ?", 
"%match%").Find(&candidates); err != nil {
+               t.Fatalf("load similar-question candidates: %v", err)
+       }
+       if len(candidates) != len(questions) {
+               t.Fatalf("loaded %d candidates, want %d", len(candidates), 
len(questions))
+       }
+
+       visibleIDs := make(map[string]bool)
+       for _, question := range candidates {
+               if canViewSimilarQuestion(question, "viewer", 
schema.QuestionPermission{}) {
+                       visibleIDs[question.ID] = true
+               }
+       }
+       if len(visibleIDs) != 2 || !visibleIDs["1"] || !visibleIDs["5"] {
+               t.Fatalf("visible similar questions = %v, want [1 5]", 
visibleIDs)
+       }
+}
+
+func TestCanViewSimilarQuestion(t *testing.T) {
+       testCases := []struct {
+               name    string
+               status  int
+               show    int
+               author  string
+               viewer  string
+               per     schema.QuestionPermission
+               allowed bool
+       }{
+               {"public question", entity.QuestionStatusAvailable, 
entity.QuestionShow, "author", "viewer", schema.QuestionPermission{}, true},
+               {"other user's pending question", entity.QuestionStatusPending, 
entity.QuestionShow, "author", "viewer", schema.QuestionPermission{}, false},
+               {"author's pending question", entity.QuestionStatusPending, 
entity.QuestionShow, "author", "author", schema.QuestionPermission{}, true},
+               {"reviewer's pending question", entity.QuestionStatusPending, 
entity.QuestionShow, "author", "reviewer", schema.QuestionPermission{CanReopen: 
true}, true},
+               {"other user's hidden question", 
entity.QuestionStatusAvailable, entity.QuestionHide, "author", "viewer", 
schema.QuestionPermission{}, false},
+               {"author's hidden question", entity.QuestionStatusAvailable, 
entity.QuestionHide, "author", "author", schema.QuestionPermission{}, true},
+               {"moderator's hidden question", entity.QuestionStatusAvailable, 
entity.QuestionHide, "author", "moderator", 
schema.QuestionPermission{IsAdminModerator: true}, true},
+               {"deleted question", entity.QuestionStatusDeleted, 
entity.QuestionShow, "author", "author", schema.QuestionPermission{}, false},
+       }
+
+       for _, testCase := range testCases {
+               t.Run(testCase.name, func(t *testing.T) {
+                       question := &entity.Question{UserID: testCase.author, 
Status: testCase.status, Show: testCase.show}
+                       if got := canViewSimilarQuestion(question, 
testCase.viewer, testCase.per); got != testCase.allowed {
+                               t.Fatalf("canViewSimilarQuestion() = %t, want 
%t", got, testCase.allowed)
+                       }
+               })
+       }
+}
+
 func TestCheckQuestionVisibility(t *testing.T) {
        testCases := []struct {
                name   string

Reply via email to