Daptin registers a generic WebSocket endpoint, GET /yjs/:documentName, for real-time collaborative
document editing (YJS/CRDT). Unlike its purpose-built sibling route, this generic endpoint performs
no per-resource authorization check - it only verifies that some user session exists. Because the
document store parses :documentName as typename.referenceId.columnName and fetches that row's
real column content unconditionally, any authenticated user (including a brand-new, zero-privilege,
self-registered account) can read - and, since YJS sync is bidirectional, also write - the content
of any file.*-typed column on any row of any table, including tables that are admin-only by
default.
InitializeYjsResources (server/endpoint_yjs.go) registers two routes.
The purpose-built, correctly-secured route, registered once per file.*-typed column on every
table:
// server/endpoint_yjs.go:47-113 (abridged)
path := fmt.Sprintf("/live/%v/:referenceId/%v/yjs", typename, columnInfo.ColumnName)
...
return func(ginContext *gin.Context) {
sessionUser := ...
if sessionUser == nil { ginContext.AbortWithStatus(403); return }
...
object, _, getErr := cruds[typename].GetSingleRowByReferenceIdWithTransaction(typename, parsedId, nil, tx)
if getErr != nil { ginContext.AbortWithStatus(404); return }
...
objectPermission := cruds[typename].GetRowPermission(object, tx2)
if !objectPermission.CanUpdate(user.UserReferenceId, user.Groups, cruds[typename].AdministratorGroupId) {
ginContext.AbortWithStatus(401)
return
}
roomName := fmt.Sprintf("%v%v%v%v%v", typename, ".", referenceId, ".", columnInfo.ColumnName)
...
yjsConnectionHandler(ginContext.Writer, ginContext.Request)
}
This route correctly requires a session, loads the actual row, and checks
objectPermission.CanUpdate(...) for the specific requesting user before allowing the WebSocket
upgrade.
A second, generic route is registered right above it, with none of those checks:
// server/endpoint_yjs.go:27-38
defaultRouter.GET("/yjs/:documentName", func(ginContext *gin.Context) {
sessionUser := ginContext.Request.Context().Value("user")
if sessionUser == nil {
ginContext.AbortWithStatus(403)
return
}
yjsConnectionHandler(ginContext.Writer, ginContext.Request)
})
The only gate here is "is some session present" - there is no lookup of the referenced row, no
GetRowPermission, no CanUpdate/CanRead check at all. :documentName is taken verbatim from
the URL and handed straight to yjsConnectionHandler.
The YJS document store's content provider parses documentName using exactly the
typename.referenceId.columnName convention the secure route builds internally as roomName, and
uses it to fetch the real row from the database with no authorization check of its own:
// server/yjs_doucment_provider.go:41-115 (abridged)
ydb.WithInitialContentProvider(func(documentPath string) []byte {
pathParts := strings.Split(documentPath, ".")
typeName, referenceId, columnName := pathParts[0], pathParts[1], pathParts[2]
crud := cruds[typeName]
object, _, getErr := crud.GetSingleRowByReferenceIdWithTransaction(typeName, parsedId,
map[string]bool{columnName: true}, tx)
...
// decodes and returns the actual file/column content, base64-decoded, as the
// initial content of the shared collaborative document
})
Because the generic route performs no permission check, any authenticated user can supply
documentName = "<any table>.<any reference_id>.<any file.* column>" and the initial YJS sync will
serve them that row's real content - including rows whose table has DefaultGroups: adminsGroup
(admin-only by default, e.g. the built-in calendar table) or rows an ordinary user's own row-level
permissions would otherwise forbid them from reading. Since YJS sync is bidirectional, a connected
client can also push edits, which legitimate collaborators may later pull back in through the
correctly secured /live/... route, giving a write/corruption path as well as a read path.
Built and ran current HEAD in a clean container; created two accounts (admin@admin.com, first
signup -> admin; bob@bob.com, second signup -> ordinary, non-admin user with default permissions
only):
# 1) Generic endpoint accepts ANY authenticated session for ANY document name,
# including a syntactically-valid-but-nonexistent reference_id on an admin-only table:
curl -i -N \
-H "Authorization: Bearer $BOB_TOKEN" \
-H "Connection: Upgrade" -H "Upgrade: websocket" \
-H "Sec-WebSocket-Version: 13" -H "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==" \
"http://localhost:6336/yjs/calendar.deadbeef-0000-0000-0000-000000000000.content"
# => HTTP/1.1 101 Switching Protocols <-- ACCEPTED, no ownership/permission check at all
# 2) The purpose-built, secured sibling route correctly validates the very same identifier:
curl -i -N \
-H "Authorization: Bearer $BOB_TOKEN" \
-H "Connection: Upgrade" -H "Upgrade: websocket" \
-H "Sec-WebSocket-Version: 13" -H "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==" \
"http://localhost:6336/live/calendar/deadbeef-0000-0000-0000-000000000000/content/yjs"
# => HTTP/1.1 404 Not Found <-- looks the row up, would 401 if it existed and Bob lacked access
# 3) Sanity check: the generic endpoint DOES require *some* session (not fully unauthenticated) --
# the flaw is specifically the missing per-resource check, not a missing session check:
curl -i -N \
-H "Connection: Upgrade" -H "Upgrade: websocket" \
-H "Sec-WebSocket-Version: 13" -H "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==" \
"http://localhost:6336/yjs/calendar.deadbeef-0000-0000-0000-000000000000.content"
# => HTTP/1.1 403 Forbidden
bob@bob.com has zero relationship to the calendar table (whose DefaultGroups is adminsGroup
typename.referenceId.columnName - reference IDs
routinely appear in ordinary list/read API responses even when the sensitive column itself is
restricted - is enough to pull that column's actual content through this side channel, fully
bypassing the row/column permission system that the sibling /live/... route (and the rest of
Daptin's permission model) correctly enforces.file.*-typed column on any row of any
table - including tables that are admin-only by default (e.g. calendar) and rows whose
row-level permissions would otherwise block that user - by supplying the right
typename.referenceId.columnName triple to GET /yjs/:documentName./live/... route.file.*-typed column (built-in
examples: calendar.content (file.ical), the generic document table's document_content
(file.*), and any custom table an admin defines with a file.xxx column type), since the
vulnerable route is registered generically for every such column across every table at startup.
Any user able to self-register (open signup is the default) is sufficient to exploit this.Fixed on the default branch in daptin/daptin@a1a3c48f. Canonical database-backed YJS rooms now use the same row lookup and existing PermissionInstance.CanUpdate/CanRead authorization for both /yjs/:documentName and /live/... routes. Update permission grants read-write access; read-only permission grants a read-only YJS session; unauthorized and missing resources fail closed with 404. Standalone non-canonical room names retain their existing authenticated, shared-by-name behavior. The initial-content provider now validates the exact canonical form, UUID, table, and file.* column before database access.
Read-only protocol enforcement is provided by artpar/ydb v0.4.1 (artpar/ydb@b79b01a), which fully consumes but drops all client YJS sync write subtypes while continuing to deliver history and broadcasts.
Verification included YDB race tests for all sync subtypes, concatenated-frame handling, persistence/broadcast suppression, catch-up, and connection continuity; Daptin permission/parser unit tests; the full Daptin test suite; server race tests; go vet; and a fresh-instance CLI/WebSocket exercise covering authentication, fail-closed canonical routes, standalone compatibility, and canonical/live cross-route relay.
No patched Daptin version is listed until a release containing a1a3c48f is published.
{
"cwe_ids": [
"CWE-639",
"CWE-862",
"CWE-863"
],
"github_reviewed": true,
"github_reviewed_at": "2026-11-20T00:14:14Z",
"nvd_published_at": "2026-11-19T17:18:59Z",
"severity": "CRITICAL"
}