CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



GHSA-9CQF-HHRQ-7V45

Missing publish-access check on getAttributeViewSearchTarget endpoint exposes database row content to unauthorized readers

Alon Barad
Alon Barad
Software Engineer

Oct 1, 2026·5 min read·21 visits

Executive Summary (TL;DR)

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.

Vulnerability Overview

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.

Root Cause Analysis

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.

Code Analysis

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.

Exploitation Mechanics

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.

Impact Assessment

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 and Mitigation

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.

Fix Analysis (1)

Technical Appendix

CVSS Score
5.3/ 10

Affected Systems

SiYuan Knowledge Workspace Platform

Affected Versions Detail

Product
Affected Versions
Fixed Version
SiYuan
siyuan-note
< 3.8.03.8.0
AttributeDetail
CWE IDCWE-862, CWE-200
Attack VectorNetwork
CVSS v3.1 Score5.3 (Medium)
Exploit StatusProof-of-Concept
KEV StatusNot Listed

MITRE ATT&CK Mapping

T1592Gather Victim Host Information
Reconnaissance

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•1 day ago•CVE-2026-128087
3.7

CVE-2026-128087: Premature Key Exchange Callback Invocation Prior to Host Key Verification in russh

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.

Amit Schendel
Amit Schendel
6 views•10 min read
•1 day ago•CVE-2026-128082
7.5

CVE-2026-128082: Uncontrolled Recursion and Denial of Service in AutoMapper via Constructor Parameter Mapping

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.

Amit Schendel
Amit Schendel
7 views•11 min read
•1 day ago•CVE-2026-128080
5.8

CVE-2026-128080: Sensitive Query Parameter Disclosure on Incoming Server Spans in OpenTelemetry JavaScript (@opentelemetry/instrumentation-http)

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.

Alon Barad
Alon Barad
7 views•10 min read
•1 day ago•CVE-2026-128089
7.5

CVE-2026-128089: Uncontrolled Resource Consumption in dnspython WKS Record Parser

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.

Amit Schendel
Amit Schendel
7 views•10 min read
•1 day ago•CVE-2026-126347
3.1

CVE-2026-126347: Open Redirect via Triple-Slash Redirect Paths in Tornado RedirectHandler

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.

Alon Barad
Alon Barad
8 views•11 min read
•1 day ago•CVE-2026-128123
5.9

CVE-2026-128123: Uncaught Exception and Denial of Service in SvelteKit @sveltejs/adapter-node

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.

Alon Barad
Alon Barad
7 views•9 min read