Nov 20, 2026·9 min read·0 visits
An authorization bypass in Daptin's generic `/yjs/:documentName` WebSocket route allows any authenticated low-privileged user to read and overwrite restricted database `file.*` column contents by passing a canonical `{typename}.{referenceId}.{columnName}` room identifier. Upgrade to version 0.12.30 to remediate.
CVE-2026-77369 is a broken access control and Insecure Direct Object Reference (IDOR) vulnerability in Daptin, an open-source headless CMS. Affected versions from 0.11.4 through 0.12.29 expose a generic YJS real-time collaboration WebSocket endpoint (`GET /yjs/:documentName`) that verifies user authentication but fails to enforce row-level authorization when supplied with a canonical database room identifier (`{typename}.{referenceId}.{columnName}`). This allows any low-privileged authenticated user to read or modify restricted database columns of type `file.*` across all entities.
Daptin is an open-source headless Content Management System (CMS) written in Go that automatically generates JSON-API and GraphQL backends from database schemas. In addition to standard REST and GraphQL operations, Daptin provides real-time collaborative editing for database columns whose data types begin with the file. prefix (such as file.txt, file.json, and file.ical). This collaborative subsystem is built on YJS, a Conflict-free Replicated Data Type (CRDT) implementation, coupled with the github.com/artpar/ydb storage backend.
To support both database-backed documents and ephemeral collaboration rooms, Daptin registers two distinct WebSocket routes during server initialization in InitializeYjsResources: a structured database route (GET /live/:typename/:referenceId/:columnName/yjs) and a generic ad-hoc route (GET /yjs/:documentName). While the structured route enforces row-level access controls before establishing a WebSocket session, the generic route in Daptin versions 0.11.4 through 0.12.29 only validates that the caller possesses an active user session.
This discrepancy introduces an authorization bypass classified under CWE-639 (Authorization Bypass Through User-Controlled Key) and CWE-862 (Missing Authorization). Because both endpoints route incoming connections to the same underlying YJS handler and document provider, an authenticated user can supply a canonical database identifier ({typename}.{referenceId}.{columnName}) to the generic /yjs/:documentName endpoint.
When the generic endpoint receives a canonical room name, the underlying YJS initial content provider parses the dot-separated string and queries the corresponding database row directly without evaluating CanRead or CanUpdate permissions. Consequently, any low-privileged authenticated user can read confidential file column contents and transmit CRDT updates that overwrite restricted database records.
The root cause of CVE-2026-77369 is an architectural inconsistency between how the HTTP routing layer authenticates requests and how the YJS storage provider resolves document identifiers. In server/endpoint_yjs.go, the dedicated route GET /live/:typename/:referenceId/:columnName/yjs explicitly loads the target row inside a database transaction, retrieves its permission bitmap via crud.GetRowPermission(object, tx), and checks objectPermission.CanUpdate(...) against the requesting user's reference ID and group memberships.
Conversely, the generic route GET /yjs/:documentName was designed for arbitrary, non-database-backed shared rooms (for example, /yjs/scratchpad). The route handler checked whether ginContext.Request.Context().Value("user") was non-nil and immediately invoked yjsConnectionHandler(ginContext.Writer, ginContext.Request). It did not inspect the :documentName parameter to determine whether it matched the canonical {typename}.{referenceId}.{columnName} syntax used internally to represent database rows.
Once yjsConnectionHandler takes over the connection, it interacts with the YJS store initialized in CreateYjsStore (server/yjs_doucment_provider.go). This store registers an initial content provider callback via ydb.WithInitialContentProvider(func(documentPath string) []byte { ... }). Whenever a room is joined, this callback splits documentPath on the . delimiter into typeName, referenceId, and columnName.
Because the WithInitialContentProvider callback executes outside the HTTP request authorization context, it assumes the caller has already been authorized to access documentPath. It looks up cruds[typeName], opens an internal database transaction, fetches the row matching referenceId, reads the file.* column data from disk or storage, and seeds the YJS CRDT document. Furthermore, when the connected client transmits YJS update frames over the WebSocket, the persistence hook writes those modifications directly back to the database column, bypassing all write protections.
In vulnerable versions of Daptin prior to 0.12.30, the generic YJS route in server/endpoint_yjs.go contained minimal validation logic, while server/yjs_doucment_provider.go performed loose parsing on the document path.
// Vulnerable code in server/endpoint_yjs.go (prior to v0.12.30)
defaultRouter.GET("/yjs/:documentName", func(ginContext *gin.Context) {
sessionUser := ginContext.Request.Context().Value("user")
if sessionUser == nil {
ginContext.AbortWithStatus(403)
return
}
logrus.Tracef("Handle new YJS client")
yjsConnectionHandler(ginContext.Writer, ginContext.Request)
})Commit a1a3c48f88ce30632a57d3fe6a971033b23bd394 resolves the vulnerability by introducing canonical room detection, unifying authorization logic across both endpoints, and upgrading github.com/artpar/ydb from v0.4.0 to v0.4.1 to enforce read-only WebSocket sessions for users who possess CanRead but lack CanUpdate permissions.
// Patched helpers in server/endpoint_yjs.go (v0.12.30)
func canonicalYjsRoomParts(documentName string) ([]string, bool) {
parts := strings.Split(documentName, ".")
if len(parts) != 3 {
return nil, false
}
// Verify the middle segment is a valid UUID referencing a row
if _, err := uuid.Parse(parts[1]); err != nil {
return nil, false
}
return parts, true
}
func yjsPermissionAccess(objectPermission permission.PermissionInstance, user *auth.SessionUser,
administratorGroupId daptinid.DaptinReferenceId) (bool, bool) {
if objectPermission.CanUpdate(user.UserReferenceId, user.Groups, administratorGroupId) {
return true, false // allowed = true, readOnly = false
}
if objectPermission.CanRead(user.UserReferenceId, user.Groups, administratorGroupId) {
return true, true // allowed = true, readOnly = true
}
return false, false // allowed = false
}The patch introduces authorizeYjsRoom, which verifies that the entity exists in cruds, validates that the target column exists and has a ColumnType prefixed with file., fetches the row inside a transaction, and evaluates yjsPermissionAccess. If the row does not exist or the user lacks both CanRead and CanUpdate, authorizeYjsRoom returns HTTP 404 to prevent leaking the existence of restricted records. The generic /yjs/:documentName route was updated to inspect all incoming room names through canonicalYjsRoomParts:
// Patched route handler in server/endpoint_yjs.go (v0.12.30)
defaultRouter.GET("/yjs/:documentName", func(ginContext *gin.Context) {
sessionUser := ginContext.Request.Context().Value("user")
if sessionUser == nil {
ginContext.AbortWithStatus(403)
return
}
user := sessionUser.(*auth.SessionUser)
documentName := ginContext.Param("documentName")
parts, isCanonicalRoom := canonicalYjsRoomParts(documentName)
if isCanonicalRoom {
roomName, readOnly, status, authorizeErr := authorizeYjsRoom(
cruds, user, parts[0], parts[1], parts[2],
)
if authorizeErr != nil {
logrus.Errorf("Failed to authorize YJS room [%s]: %v", documentName, authorizeErr)
}
if status != 0 {
ginContext.AbortWithStatus(status)
return
}
serveYjsRoom(ginContext, yjsConnectionHandler, roomName, readOnly)
return
}
serveYjsRoom(ginContext, yjsConnectionHandler, documentName, false)
})To assess fix completeness, the patch also hardens CreateYjsStore in server/yjs_doucment_provider.go. Previously, the initial content provider checked if len(pathParts) < 3, which allowed a four-part string such as typename.uuid.column.extra to bypass a strict 3-part check while still resolving pathParts[0..2] against the database. By changing the condition in yjs_doucment_provider.go to if len(pathParts) != 3 and validating uuid.Parse(referenceId) in both the router and the provider, the fix eliminates delimiter-padding bypasses.
Exploiting CVE-2026-77369 requires network access to the Daptin HTTP/WebSocket listener (default port 6336) and a valid JWT session token belonging to any low-privileged user account. Unauthenticated requests are rejected with HTTP 403 Forbidden because sessionUser == nil is checked at the start of the handler. Additionally, the attacker must know or enumerate the target table name (typename), the 36-character row UUID (referenceId), and the name of a file.* column (columnName).
In a standard deployment, attempting to access a restricted row via the dedicated collaboration endpoint results in an immediate authorization failure:
GET /live/document/11111111-1111-1111-1111-111111111111/content/yjs?token=<LOW_PRIV_JWT> HTTP/1.1
Host: target.example.com:6336
Upgrade: websocket
Connection: Upgrade
HTTP/1.1 401 UnauthorizedTo bypass this restriction on vulnerable versions (>= 0.11.4, < 0.12.30), the attacker reformats the path segments into a dot-delimited room name and initiates a WebSocket connection against /yjs/:documentName:
GET /yjs/document.11111111-1111-1111-1111-111111111111.content?token=<LOW_PRIV_JWT> HTTP/1.1
Host: target.example.com:6336
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
Sec-WebSocket-Version: 13Once the WebSocket handshake succeeds with HTTP/1.1 101 Switching Protocols, the server invokes CreateYjsStore to load the initial content of document.11111111-1111-1111-1111-111111111111.content. During the YJS synchronization handshake (SyncStep1 and SyncStep2), the server streams the binary CRDT state vector containing the complete file contents to the attacker's client.
If the attacker subsequently transmits YJS update frames modifying the shared CRDT state, the server processes the binary updates without checking CanUpdate or WithReadOnlySession flags. The modified content is then persisted directly into the database row's file.* column, overwriting the original data.
CVE-2026-77369 carries a CVSS v3.1 base score of 9.6 (Critical) with the vector CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:N. The Scope is marked as Changed (S:C) because a flaw in the WebSocket collaboration router allows an attacker to breach the authorization boundaries enforced by the core database storage and permission engine.
The confidentiality impact is High (C:H). Any authenticated user, regardless of group membership or ownership levels, can exfiltrate the contents of any file.* column across all configured entities in the Daptin instance. In multi-tenant or enterprise deployments where self-registration or guest accounts are enabled, this allows horizontal and vertical data access across tenant boundaries.
The integrity impact is also High (I:H). Because YJS synchronization is bidirectional by default in vulnerable versions, connecting to a canonical room grants unrestricted write capabilities over the underlying column data. An attacker can modify, corrupt, or clear stored files and structured documents (such as file.json or file.ical objects) belonging to administrators or other users.
The availability impact is rated as None (A:N) in the official CVSS vector because the vulnerability does not crash the server process or exhaust host resources, though overwriting critical application files stored in file.* columns can degrade functional availability of individual records. At the time of publication, the vulnerability is not listed in the CISA Known Exploited Vulnerabilities (KEV) catalog, and no public exploitation in the wild has been reported.
Administrators running Daptin versions between 0.11.4 and 0.12.29 should upgrade immediately to version v0.12.30 or later. Version v0.12.30 incorporates commit a1a3c48f88ce30632a57d3fe6a971033b23bd394 (Enforce row permissions for YJS rooms) and upgrades github.com/artpar/ydb to v0.4.1, ensuring that canonical room requests on /yjs/:documentName undergo the same row-level permission checks as /live/:typename/:referenceId/:columnName/yjs.
> [!NOTE]
> After upgrading to v0.12.30, users who possess CanRead permission on a row (without CanUpdate) can still connect to the YJS room to view live document state, but their session is wrapped with ydb.WithReadOnlySession, causing the server to ignore any incoming write updates.
If an immediate software upgrade is not feasible, administrators should deploy a reverse proxy or Web Application Firewall (WAF) rule in front of the Daptin instance (default port 6336) to filter requests to the /yjs/ prefix. Specifically, any request to /yjs/:documentName where :documentName matches the canonical three-part dot-separated pattern containing a UUID should be blocked at the perimeter:
# Example Nginx location block to block canonical DB rooms on the generic YJS route
location ~* ^/yjs/[^/]+\.[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.[^/]+$ {
return 403;
}Security teams should also audit historical HTTP and WebSocket access logs for GET /yjs/ requests containing two dot separators and a 36-character UUID segment. Any such requests originating from non-administrative accounts prior to patching should be investigated as potential unauthorized data access or tampering events.
CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:N| Product | Affected Versions | Fixed Version |
|---|---|---|
daptin daptin | >= 0.11.4, < 0.12.30 | 0.12.30 |
| Attribute | Detail |
|---|---|
| CVE ID | CVE-2026-77369 (GHSA-wj7x-58c2-5793) |
| CWE Classification | CWE-639 (Authorization Bypass Through User-Controlled Key) / CWE-862 (Missing Authorization) |
| CVSS v3.1 Score | 9.6 Critical (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:N) |
| Attack Vector | Network via WebSocket (GET /yjs/:documentName) |
| Privileges Required | Low (Any authenticated user session) |
| Security Impact | Unauthorized read and write access to database file.* columns across all entities |
| Patched Version | Daptin v0.12.30 |
| CISA KEV Status | Not Listed |
The system uses key user-controllable input (the :documentName parameter) to access a sensitive database resource without verifying that the requesting actor has permission to access that resource.
CVE-2026-77376 is an open redirect vulnerability (CWE-601) in the core framework of Bolt CMS prior to version 6.1.4. The vulnerability resides within the LoginFormAuthenticator class, which processes post-authentication redirection for both successful and failed login attempts. Due to a lack of destination validation, the application accepts untrusted target paths from user sessions and directly reflects unvalidated HTTP Referer headers into HTTP Location response headers. Attackers can exploit this behavior to redirect users to arbitrary external domains after interacting with the Bolt login endpoint, facilitating credential harvesting and phishing attacks.
Bolt CMS (bolt/core) versions prior to 6.1.4 contain a Server-Side Request Forgery (SSRF) vulnerability in the authenticated URL-upload (/async/upload-url) and media embed (/async/embed) endpoints. Backend users with file upload or media embedding privileges can supply arbitrary URLs that the application fetches without destination IP validation. This allows authenticated attackers to force the server to initiate HTTP requests to loopback interfaces, RFC 1918 private networks, and cloud instance metadata services.
Bolt CMS prior to version 6.1.4 contains an information disclosure vulnerability in its public Relation API endpoints. The Doctrine ORM query extension (ContentExtension) fails to filter out unpublished, draft, or viewless content when querying the Relation entity. Because the Relation resource is configured with public read access (PUBLIC_ACCESS) via API Platform REST and GraphQL endpoints, unauthenticated remote attackers can enumerate relationship graphs, entity identifiers, and metadata associated with private content.
Bolt CMS prior to version 6.1.5 is vulnerable to Server-Side Request Forgery (SSRF) in its asynchronous URL upload and media embed endpoints. While the application validates the initial user-supplied URL against internal network ranges using UrlSafetyChecker, the underlying HTTP transport libraries automatically follow HTTP 3xx redirects and HTML meta refresh directives without re-validating the target destinations. An authenticated user with editor privileges can exploit this discrepancy via an open redirector or DNS rebinding to access internal network resources and cloud metadata services.
CVE-2026-77378 (GHSA-r7h9-qx4h-77j5) is an authenticated SQL injection vulnerability affecting the bolt/core package of Bolt CMS in versions prior to 6.1.4. The flaw resides in the ListFormatHelper utility class, where content-type slugs are dynamically interpolated into raw SQL query strings via sprintf rather than bound as parameterized inputs. When the general/caching/list_format configuration directive is enabled, an authenticated user with upload privileges can exploit the /async/select-options endpoint to inject arbitrary SQL commands and query the underlying database.
A cryptographic soundness defect in the discrete-Gaussian sampler of falcon-rust prior to version 0.2.0 degrades acceptance-probability precision to approximately 2^-33. By evaluating exponential approximations using 32-bit fractional fixed-point arithmetic (FixedPoint64) and left-shifting polynomial inputs by 31 bits, the implementation violates Falcon's required precision bound of 2^-40 to 2^-46, invalidating the theoretical security reduction against statistical private key leakage.