On this page (7 sections)

Daptin, an open source GraphQL/JSON-API headless CMS written in Go, has a critical broken access control flaw in its real-time collaboration feature. Any logged-in user, even a freshly self-registered account with no special rights, can reach a WebSocket route that hands out the content of restricted file columns and accepts edits to it. The issue is tracked as CVE-2026-77369 and fixed in Daptin 0.12.30.

If you run Daptin anywhere, especially with open self-registration or on the public internet, this is worth patching now. The technical details come from a single GitHub-reviewed advisory, which is also published in the daptin/daptin repository, and the CVE record that draws on it. There is no independent confirmation yet, so treat details beyond the advisory as unconfirmed.

What happened

Daptin exposes a generic WebSocket route, GET /yjs/:documentName, used for collaborative document editing based on YJS (a CRDT technique for syncing shared documents). According to the advisory, this route only checks that some user session exists. It does not check whether that user is allowed to see or change the data the requested document name points to.

Daptin also has a purpose-built collaboration route that does the right thing: it loads the row and checks that the specific user has update permission before upgrading the connection. The generic route skips all of that, which is the core of the bug.

Technical details in plain terms

The document name follows a typename.referenceId.columnName pattern. The advisory explains that the content provider behind the YJS store splits the name on dots, looks up the matching row and file-typed column in the database, and returns that content as the starting content of the shared document. No read or update permission check happens in that step either.

This is a classic insecure direct object reference (IDOR): the client chooses which object to access by supplying an identifier, and the server never asks whether this user should have it. Because YJS synchronization is bidirectional, the problem is not read-only. The advisory says a connected client can also push edits, which legitimate collaborators may later pull back in through the correctly secured route. That creates a path for tampering and corrupting content, not just disclosure.

The advisory states that the affected data includes file-typed columns on any table, including tables that are admin-only by default, and that a brand-new self-registered account is enough. It also notes the limits: unauthenticated requests are rejected, and standalone room names that do not follow the canonical pattern remain shared-by-name rooms, as designed.

Who is realistically exposed

  • Daptin instances on versions 0.11.4 up to and including 0.12.29.
  • Deployments where anyone can register an account. The advisory describes the second signup as an ordinary non-admin user, so open signup lowers the barrier to almost nothing.
  • Instances that store sensitive material in file-typed columns, such as documents, attachments or configuration content, and rely on row or table permissions to protect it.
  • Setups where Daptin is reachable from the internet rather than only from a trusted internal network.

Because the flaw needs an authenticated session, a Daptin instance with no registered users other than trusted staff has a smaller practical exposure. Even so, any low-privilege account (a customer, contractor or compromised user) becomes a way to reach data it was never meant to touch.

How to check your exposure

First find out which version you run. If you run Daptin from a binary, check the release you downloaded and deployed. If you use Docker, the command below lists the Daptin image tags present on the host, so you can compare them with 0.12.30. It is read-only.

List Daptin image tags present on a Docker host (read-only)Shell
docker images | grep -i daptin

If your project is built from Go source and imports Daptin as a module, the command below prints the resolved module version. Run it from the project directory and look for a version below v0.12.30.

Show the resolved Daptin module version in a Go project (read-only)Shell
go list -m github.com/daptin/daptin

Then review your reverse proxy or application logs for WebSocket upgrade requests to paths starting with /yjs/. Requests from accounts that should not be collaborating on documents, or document names that reference tables those users cannot normally read, deserve a closer look. The research does not describe a known attack signature, so this is a review step, not proof of compromise. The command below searches an nginx access log for those requests; adjust the path to your own log location.

Search an nginx access log for requests to the generic YJS route (adjust the log path)Shell
grep '/yjs/' /var/log/nginx/access.log

What to do now

  1. Upgrade Daptin to 0.12.30 or later, using the v0.12.30 release.
  2. If you cannot upgrade immediately, temporarily disable open self-registration and review the list of existing user accounts, removing any you do not recognize.
  3. Consider restricting access to the instance (VPN, IP allow list or authenticated reverse proxy) until the patch is in place.
  4. Review logs for requests to /yjs/ and note which accounts made them.
  5. Check file-typed columns on sensitive tables for unexpected changes, since the flaw allows writes as well as reads.
  6. If you find signs of misuse, treat stored secrets or documents in those columns as exposed and rotate them.
  7. Re-test after upgrading by confirming the running version is 0.12.30 or newer.
Caution. Upgrading a CMS backend restarts the service and can change behavior. Back up your database and configuration first, and test the new version in staging if you can.

The advisory also references a commit in the project repository. We have not verified its contents, so rely on the tagged release rather than applying individual changes yourself.

Detection and monitoring afterwards

Access control bugs leave little trace unless you log at the application layer. Keep WebSocket upgrade requests in your proxy logs, and alert on /yjs/ requests from non-admin accounts. Periodically audit who has accounts, and review permissions on tables that hold file-typed columns, since defaults such as admin-only tables are exactly what this bug bypassed.

If your Daptin instance is public, an outside view helps too. A security scan of your own verified site can flag exposed services and outdated components, and monitoring can alert on unexpected certificate, DNS or header changes. Neither replaces patching, and neither is specific to this flaw.

Confidence and open questions

This write-up relies on the GitHub-reviewed advisory and the CVE record, which draws on the same advisory. It is primary material but effectively a single source, so there is no independent confirmation yet. The dates also differ: the CVE record lists publication on 2026-11-19, while the advisory page shows July 12, 2026 as its published date and November 20, 2026 as its last update. We do not know the reason for the difference. The research reports no exploitation and shows no CISA KEV entry, so exploitation status is unconfirmed. Plan as if it could happen and patch promptly.

Sources

This article is based on the public sources below. Details can change as vendors and researchers publish more; check the original advisories before acting on version numbers.

  1. CVE-2026-77369 - GitHub Advisory Databasegithub.com
  • Daptin
  • CVE-2026-77369
  • IDOR
  • Broken access control
  • Headless CMS
  • Go