Skip to content

A Q&A platform software for teams at any scales. Whether it's a community forum, help center, or knowledge management platform, you can always count on Apache Answer.

fix(security): restrict similar question visibility

LinkinStars41a9d887d936
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