Oct 1, 2026·5 min read·21 visits
Missing publish-access check on the /api/av/getAttributeViewSearchTarget endpoint in SiYuan allows unauthorized substring-based extraction of private database row contents.
An authorization bypass and information leakage vulnerability exists in the SiYuan database module. Unauthenticated users can query the getAttributeViewSearchTarget API endpoint using target block identifiers to extract private content.
The SiYuan knowledge workspace platform is vulnerable to an information exposure flaw within its database module (Attribute Views). The vulnerability, registered under GHSA-9CQF-HHRQ-7V45, permits unauthorized access to unpublished database records. This issue affects instances that host published notebooks or serve public facing web content.
To manage public content safely, the server must validate access controls before exposing any document node. The endpoint /api/av/getAttributeViewSearchTarget does not perform the required publish-access validation. Consequently, unauthenticated users can probe the backend database blocks through substring queries.
This behavior exposes sensitive cell values and row metadata from private or encrypted notebooks. An attacker with network access to the API can exploit this behavior to systematically extract data without authorization.
The vulnerability stems from a missing authorization check inside the newly introduced endpoint /api/av/getAttributeViewSearchTarget. The endpoint was implemented to support search navigation across attribute views in database rows. While it implements a basic authentication check (model.CheckAuth), it does not verify whether the targeted document block resides inside a published notebook.
When a user queries the endpoint, the application retrieves the target block ID and decrypts the underlying storage if encryption is active. The system then performs substring comparisons against all key-value entries in that database block. If any substring match is successful, the server returns the fully resolved row title and metadata.
This architecture creates a side-channel substring oracle. The application fails to restrict this API endpoint based on notebook visibility settings. As a result, an attacker can extract sensitive cell values by submitting targeted guess queries and observing the structured response.
The registration of the vulnerable endpoint in the backend router lacks access restriction middlewares. The registration logic in kernel/api/router.go appears as follows:
// Vulnerable endpoint registration
ginServer.Handle("POST", "/api/av/getAttributeViewSearchTarget", model.CheckAuth, getAttributeViewSearchTarget)The CheckAuth handler only validates that the session is authenticated or active, but does not verify whether the specific notebook (tree.Box) containing the target block is published or accessible to the current privilege level.
The search logic inside kernel/model/attribute_view_render.go parses the attribute view and retrieves data directly from the notebook storage:
// Vulnerable block retrieval and matching logic
func GetAttributeViewSearchTarget(blockID string, keywords []string) (ret *AttributeViewSearchTarget) {
waitForSyncingStorages()
node, tree, _ := getNodeByBlockID(nil, blockID)
if nil == node || nil == tree || ast.NodeAttributeView != node.Type || "" == node.AttributeViewID {
return
}
// Node and tree are parsed without verifying if the notebook (tree.Box) is published
var attrView *av.AttributeView
var err error
if IsEncryptedBox(tree.Box) {
attrView, err = av.ParseAttributeViewInBox(node.AttributeViewID, tree.Box)
} else {
attrView, err = av.ParseAttributeView(node.AttributeViewID)
}
// ...The server constructs the return payload directly using the sensitive string values if a match is found:
ret = &AttributeViewSearchTarget{
AvID: attrView.ID,
DatabaseBlockID: blockID,
NotebookID: tree.Box,
ItemID: itemID,
ValueID: blockValue.ID,
MatchedValueID: match.valueID,
MatchedKeyID: match.keyID,
Title: blockValue.String(true), // Exposes the raw string content
BoundBlockID: blockValue.Block.ID,
IsDetached: blockValue.IsDetached || "" == blockValue.Block.ID,
Keywords: keywords,
}To resolve this flaw, the handler must check the publish state of the requested notebook. If the notebook is not published and the request is unauthenticated, the operation must abort.
An attacker can exploit this vulnerability by executing structured HTTP POST requests against the /api/av/getAttributeViewSearchTarget endpoint. The attack does not require advanced privileges if the instance exposes public pages or operates in a multi-user environment. The process follows a systematic query pattern.
The attacker constructs a JSON request body containing a target block identifier and a series of guess strings. If any guess matches a substring within the private database record, the backend responds with the full content of the row. An example payload demonstrates this mechanism:
POST /api/av/getAttributeViewSearchTarget HTTP/1.1
Host: target.local
Content-Type: application/json
{
"id": "20260726000000-privateblock",
"keywords": ["Confidential", "Secret", "Credential"]
}If the matching algorithm succeeds, the backend returns a JSON payload containing the field "Title": "Confidential Database Record". By iterating through alphabet characters or dictionary terms, an attacker can reconstruct full cell values.
The security impact of this vulnerability involves a partial loss of confidentiality. Because the endpoint does not modify data, integrity and availability remain unaffected. This leads to a CVSS score classification based primarily on information exposure.
Attackers can leverage this endpoint as a decryption or extraction vector for otherwise protected notes. If a database contains high-value assets such as configuration variables, tokens, or personal identifiers, these assets can be retrieved remotely. The vulnerability bypasses both folder-level permission restrictions and notebook-level database encryption once a block ID is known.
In environments where SiYuan is deployed as a public wiki, the exposure risk is elevated. Unauthenticated web crawlers or targeted actors can enumerate private block structures. This allows unauthorized parties to compile sensitive data repositories from the host system.
Remediation requires modifying the backend router and query handlers to validate document ownership and publish status. Users must upgrade to a version of SiYuan that includes server-side access control validation on all database search endpoints. Relying on client-side interface patches is insufficient because raw API requests bypass UI-level restrictions.
If immediate upgrading is not possible, administrators should disable the public publishing feature. Restricting network access to the SiYuan API using reverse proxies or firewalls also reduces the exposure vector. Restrict access exclusively to authenticated local users.
Implement security group rules that monitor traffic patterns. A high volume of requests to /api/av/getAttributeViewSearchTarget from unauthenticated IP addresses indicates active scanning. Security teams should inspect logs for unauthorized calls to this specific endpoint.
| Product | Affected Versions | Fixed Version |
|---|---|---|
SiYuan siyuan-note | < 3.8.0 | 3.8.0 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-862, CWE-200 |
| Attack Vector | Network |
| CVSS v3.1 Score | 5.3 (Medium) |
| Exploit Status | Proof-of-Concept |
| KEV Status | Not Listed |
CVE-2026-128087 (GHSA-9264-jvgf-6w2f) is an incorrect behavior order (CWE-696) and improper authorization (CWE-863) vulnerability in the russh Rust SSH library, affecting versions 0.55.0 through 0.65.0. During the initial SSH key exchange (KEX) handshake, the client state machine invokes the client::Handler::kex_done() callback—providing the negotiated raw shared secret bytes—prior to validating the remote server's host key or certificate via check_server_key(). Consequently, an untrusted or rogue SSH server can complete cryptographic key agreement and force a connecting client to execute side-effecting application logic inside kex_done() before the server's identity is checked and rejected.
CVE-2026-128082 (GHSA-6vhm-j9h7-f9gh) is an uncontrolled recursion vulnerability (CWE-674) in AutoMapper, a convention-based object-object mapper for .NET. When mapping nested or self-referential types into destination models that rely on parameterized constructors, C# positional records, or recursive ConstructUsing expressions, AutoMapper evaluates child constructor arguments prior to incrementing the parent's recursion depth counter. This ordering flaw bypasses both explicit MaxDepth limits and the default depth limit of 64. An unauthenticated remote attacker can supply deeply nested input payloads to affected endpoints, exhausting the thread call stack and triggering an uncatchable System.StackOverflowException that terminates the hosting .NET process.
An information exposure vulnerability in the @opentelemetry/instrumentation-http package for OpenTelemetry JavaScript versions 0.204.0 prior to 0.222.0 causes incoming HTTP server spans to record raw, unredacted query string parameters under the url.query attribute. While outgoing client spans applied built-in and user-configured query parameter redaction, incoming server spans bypassed this sanitization completely, resulting in the transmission of sensitive credentials such as pre-signed cloud URLs and API tokens to external observability backends.
CVE-2026-128089 is an uncontrolled resource consumption vulnerability in the dnspython toolkit for Python, affecting all versions prior to 2.9.2. When parsing Well-Known Service (WKS) records from text via dns.rdtypes.IN.WKS.WKS.from_text(), the parser fails to validate that numeric service port identifiers fall within the RFC 1035 valid range of 0 through 65535. An attacker capable of supplying untrusted zone files or RDATA text strings containing an arbitrarily large service port integer can force the parser to allocate an unbounded bitmap array using an inefficient linear append loop, resulting in severe CPU exhaustion, application hangs, or Out-Of-Memory (OOM) process termination.
CVE-2026-126347 (GHSA-5cjw-f85j-cv6r) is an open redirect vulnerability (CWE-601) in Tornado, an asynchronous Python networking library and web framework. The flaw resides in tornado.web.RedirectHandler when dynamic URL redirection templates incorporate unvalidated user input. Due to a parser differential between RFC 3986 (used by Python's urllib.parse.urlsplit) and the WHATWG URL Standard (used by modern web browsers), inputs containing three or more leading slashes bypass Tornado 6.6.0's validation logic, allowing unauthenticated attackers to redirect users to arbitrary external domains.
A Denial of Service (DoS) vulnerability exists in @sveltejs/adapter-node versions 5.5.7 and 6.0.0-next.0 through 6.0.0. When a SvelteKit server route returns a direct response from a fetch() call with a Content-Type of text/event-stream, the Node.js adapter attempts to mutate the response headers to disable proxy buffering. Because headers returned directly by the WHATWG Fetch API carry an immutable guard, this mutation throws an unhandled TypeError, terminating the underlying Node.js process and denying service to all active and subsequent clients.