An open-source, privacy-first, self-hosted knowledge workspace where humans and AI agents work together 开源、隐私优先、自托管的知识工作空间,让人与智能体在此协作
TypeScript agentic-aiai-agentknowledge-baselocal-firstmarkdownmcpmindmapnote-takingself-hostedsiyuanworkspace
// SiYuan - https://github.com/siyuan-note/siyuan
// Copyright (c) 2020-present, b3log.org
// SPDX-License-Identifier: AGPL-3.0-or-later
//go:build fts5
package api
import (
"encoding/json"
"net/http"
"net/http/httptest"
"os"
"path/filepath"
"strings"
"testing"
"github.com/88250/lute/ast"
"github.com/gin-gonic/gin"
"github.com/siyuan-note/siyuan/kernel/conf"
"github.com/siyuan-note/siyuan/kernel/filesys"
"github.com/siyuan-note/siyuan/kernel/model"
"github.com/siyuan-note/siyuan/kernel/sql"
"github.com/siyuan-note/siyuan/kernel/treenode"
"github.com/siyuan-note/siyuan/kernel/util"
)
// getDocPublishProbe 只保留断言需要的字段。
type getDocPublishProbe struct {
Code int `json:"code"`
Msg string `json:"msg"`
Data struct {
Content string `json:"content"`
Keywords []string `json:"keywords"`
PublishAccessRequired bool `json:"publishAccessRequired"`
} `json:"data"`
}
// containsKeyword 判断检索片段中是否包含指定文本。
func containsKeyword(keywords []string, text string) bool {
for _, keyword := range keywords {
if strings.Contains(keyword, text) {
return true
}
}
return false
}
// TestGetDocKeywordsPublishAccess 验证读者请求密码保护或禁止发布的文档时,
// getDoc 不通过 keywords 返回正文检索片段,同时确认发布可见文档的检索片段不受影响。
// https://github.com/siyuan-note/siyuan/security/advisories/GHSA-qf37-w288-frvq
func TestGetDocKeywordsPublishAccess(t *testing.T) {
previousConf := model.Conf
previousWorkspaceDir, previousConfDir, previousDataDir := util.WorkspaceDir, util.ConfDir, util.DataDir
previousTempDir, previousDBPath, previousBlockTreeDBPath := util.TempDir, util.DBPath, util.BlockTreeDBPath
previousHistoryDBPath, previousAssetContentDBPath := util.HistoryDBPath, util.AssetContentDBPath
root := t.TempDir()
t.Cleanup(func() {
model.Conf = previousConf
util.WorkspaceDir, util.ConfDir, util.DataDir = previousWorkspaceDir, previousConfDir, previousDataDir
util.TempDir, util.DBPath, util.BlockTreeDBPath = previousTempDir, previousDBPath, previousBlockTreeDBPath
util.HistoryDBPath, util.AssetContentDBPath = previousHistoryDBPath, previousAssetContentDBPath
})
util.WorkspaceDir = root
util.ConfDir = filepath.Join(root, "conf")
util.DataDir = filepath.Join(root, "data")
util.TempDir = filepath.Join(root, "temp")
util.DBPath = filepath.Join(util.TempDir, "siyuan.db")
util.HistoryDBPath = filepath.Join(util.TempDir, "history.db")
util.AssetContentDBPath = filepath.Join(util.TempDir, "asset_content.db")
util.BlockTreeDBPath = filepath.Join(util.TempDir, "blocktree.db")
for _, dir := range []string{util.ConfDir, util.DataDir, util.TempDir} {
if err := os.MkdirAll(dir, 0755); err != nil {
t.Fatal(err)
}
}
model.Conf = model.NewAppConf()
model.Conf.Lang = "en"
model.Conf.FileTree.Store(conf.NewFileTree())
model.Conf.Editor.Store(conf.NewEditor())
model.Conf.Export.Store(conf.NewExport())
model.Conf.Search.Store(conf.NewSearch())
model.Conf.NotebookCrypto = conf.NewNotebookCrypto()
model.Conf.Sync.Store(conf.NewSync())
const (
boxID = "20261026000000-boxkw01"
protectedDocID = "20261026000001-dockw01"
protectedBlockID = "20261026000002-blkkw01"
disabledDocID = "20261026000003-dockw02"
disabledBlockID = "20261026000004-blkkw02"
publicDocID = "20261026000005-dockw03"
publicBlockID = "20261026000006-blkkw03"
protectedPassword = "probe-password"
protectedSentinel = "PROTECTED_SECRET_A1B2C3"
disabledSentinel = "DISABLED_SECRET_D4E5F6"
visibleSentinel = "VISIBLE_TEXT_A7B8C9"
nonMatchingPattern = "^NO_MATCH_FOR_GETDOC_PROBE_8592$"
broadRegexp = `(?s)(?:.+)`
)
box := &model.Box{ID: boxID}
boxConf := conf.NewBoxConf()
boxConf.Name = "getDoc keywords publish access"
boxConf.Closed = false
if err := box.SaveConf(boxConf); err != nil {
t.Fatal(err)
}
sql.InitDatabase(true)
sql.InitHistoryDatabase(true)
sql.InitAssetContentDatabase(true)
treenode.InitBlockTree(true)
t.Cleanup(func() {
sql.CloseDatabase()
treenode.CloseDatabase()
})
previousPublishAccess := model.GetPublishAccess()
if err := model.SetPublishAccess(model.PublishAccess{
{ID: protectedDocID, Visible: true, Password: protectedPassword},
{ID: disabledDocID, Disable: true},
}); err != nil {
t.Fatalf("set publish access failed: %v", err)
}
t.Cleanup(func() { _ = model.SetPublishAccess(previousPublishAccess) })
addDoc := func(docID, title, blockID, content string) {
tree := treenode.NewTree(boxID, "/"+docID+".sy", "/"+title, title)
tree.Root.FirstChild.Unlink()
paragraph := &ast.Node{Type: ast.NodeParagraph, ID: blockID}
paragraph.AppendChild(&ast.Node{Type: ast.NodeText, Tokens: []byte(content)})
tree.Root.AppendChild(paragraph)
treenode.IndexBlockTree(tree)
if _, err := filesys.WriteTree(tree); err != nil {
t.Fatal(err)
}
sql.IndexTreeQueue(tree)
}
addDoc(protectedDocID, "Protected", protectedBlockID, protectedSentinel)
addDoc(disabledDocID, "Disabled", disabledBlockID, disabledSentinel)
addDoc(publicDocID, "Public", publicBlockID, visibleSentinel)
sql.FlushQueue()
gin.SetMode(gin.TestMode)
engine := gin.New()
engine.Use(boxLeaseMiddleware)
engine.Use(func(c *gin.Context) { c.Set(model.RoleContextKey, model.RoleReader); c.Next() })
engine.POST("/api/filetree/getDoc", getDoc)
protectedAuthCookie := &http.Cookie{
Name: "publish-auth-" + protectedDocID,
Value: util.SHA256Hash([]byte(protectedDocID + protectedPassword)),
}
tests := []struct {
name string
docID string
query string
queryMethod int
cookie *http.Cookie
wantGate string
wantPasswordRequired bool
wantKeyword string
wantSentinelInContent string
}{
{"protected regex", protectedDocID, broadRegexp, 3, nil, "protyle-password", true, "", ""},
{"protected control", protectedDocID, nonMatchingPattern, 3, nil, "protyle-password", true, "", ""},
{"protected fts", protectedDocID, protectedSentinel, 1, nil, "protyle-password", true, "", ""},
{"protected authorized", protectedDocID, broadRegexp, 3, protectedAuthCookie, "", false, protectedSentinel, protectedSentinel},
{"disabled regex", disabledDocID, broadRegexp, 3, nil, "protyle-password--forbidden", false, "", ""},
{"visible regex", publicDocID, broadRegexp, 3, nil, "", false, visibleSentinel, visibleSentinel},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
body, err := json.Marshal(map[string]any{
"id": test.docID,
"query": test.query,
"queryMethod": test.queryMethod,
"queryTypes": map[string]bool{"paragraph": true},
})
if err != nil {
t.Fatal(err)
}
request := httptest.NewRequest(http.MethodPost, "/api/filetree/getDoc", strings.NewReader(string(body)))
request.Header.Set("Content-Type", "application/json")
if nil != test.cookie {
request.AddCookie(test.cookie)
}
recorder := httptest.NewRecorder()
engine.ServeHTTP(recorder, request)
response := getDocPublishProbe{}
if err = json.Unmarshal(recorder.Body.Bytes(), &response); err != nil {
t.Fatalf("decode response failed: %v, body: %s", err, recorder.Body.String())
}
if 0 != response.Code {
t.Fatalf("unexpected response code [%d]: %s", response.Code, recorder.Body.String())
}
if test.wantPasswordRequired != response.Data.PublishAccessRequired {
t.Fatalf("publishAccessRequired = %t, want %t: %s", response.Data.PublishAccessRequired, test.wantPasswordRequired, recorder.Body.String())
}
if "" != test.wantGate && !strings.Contains(response.Data.Content, test.wantGate) {
t.Fatalf("content does not contain the publish gate [%s]: %s", test.wantGate, recorder.Body.String())
}
if "" == test.wantGate && strings.Contains(response.Data.Content, "protyle-password") {
t.Fatalf("content should be readable but shows a publish gate: %s", recorder.Body.String())
}
if "" != test.wantSentinelInContent && !strings.Contains(response.Data.Content, test.wantSentinelInContent) {
t.Fatalf("content does not contain the document body [%s]: %s", test.wantSentinelInContent, recorder.Body.String())
}
if "" != test.wantKeyword {
if !containsKeyword(response.Data.Keywords, test.wantKeyword) {
t.Fatalf("keywords do not contain the document body [%s]: %s", test.wantKeyword, recorder.Body.String())
}
} else if 0 != len(response.Data.Keywords) {
t.Fatalf("keywords should be empty when publish access is restricted: %s", recorder.Body.String())
}
})
}
}