/

CVE-2026-56773

Severity:

HIGH RISK

(8.8)

Missing Authorization (CWE-862) in Teable v2 REST API

CVE-2026-56773

Deferred

Vulnerability type

Category:

Missing Authorization

CWE:

CWE-862

Impact:

Unauthorized Data Access and Modification

Severity:

HIGH RISK

(8.8)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

Teable's v2 REST API ORPC endpoints lack proper authorization metadata, allowing any authenticated user to invoke sensitive table operations without permission checks.

Under these conditions, an attacker can read schemas, create tables, and modify or delete records across bases and tables via exposed API routes.

Affected context

This vulnerability manifests in Teable deployments that expose the v2 REST API, particularly ORPC endpoints implemented without @Permissions metadata or equivalent authorization guards.

It becomes relevant when the application treats any authenticated session as sufficient to call administrative or data-manipulation endpoints, and when backend access control is assumed but not enforced at the controller level.

Exploit preconditions

  • Attack surface: Teable v2 REST API over HTTP(S), including ORPC endpoints such as /api/v2/tables/get and /api/v2/tables/updateRecords.
  • Required access: Any valid authenticated user account in the Teable instance; elevated roles (e.g., admin) are not required.
  • Trigger point: Invocation of unprotected endpoints that execute table and record operations without verifying per-resource permissions.
  • Why exploitation is possible: The controller methods lack @Permissions metadata or equivalent checks, causing the authorization layer to skip validation and treat all authenticated users as authorized for those operations.

Why this happens

The underlying issue is a missing authorization control at the API controller level, aligning with CWE-862 (Missing Authorization).

ORPC endpoints are implemented without explicit permission annotations (@Permissions) or consistent access-control enforcement, so the framework does not apply resource-level authorization checks.

As a result, the system relies solely on authentication, conflating "logged in" with "authorized", and exposing sensitive table-management and record-manipulation capabilities to any user.

Potential impact

  • Any authenticated user may read table schemas and metadata across bases.
  • Attackers could create new tables to store or exfiltrate data.
  • Existing records can be modified, corrupted, or deleted without proper authorization.
  • Business-critical datasets may be tampered with, leading to data integrity loss.
  • Unauthorized access to tenant or project data can occur in multi-user environments.

General mitigation guidance

Effective mitigation focuses on enforcing authorization at every sensitive API operation and avoiding assumptions that authentication alone is sufficient.

Common defensive patterns include:

  • Applying explicit permission annotations (such as @Permissions) on all controller methods that read or mutate table structures or records.
  • Centralizing authorization logic so that ORPC and REST handlers consistently check resource-level permissions before execution.
  • Designing APIs with least-privilege defaults, ensuring newly added endpoints require explicit permission mapping.
  • Separating authentication from authorization in the architecture, so role- and resource-based checks are mandatory for data access.
  • Regularly reviewing API surface for endpoints that perform cross-base or cross-table operations and ensuring they enforce access-control policies.

How teams detect issues like this

Organizations can detect similar missing-authorization issues through:

  • Static analysis or linters that flag controller methods lacking required authorization decorators or middleware.
  • Code review practices that require explicit permission mapping for every new API endpoint, especially those touching shared or multi-tenant data.
  • Automated tests that attempt operations with low-privilege accounts and assert denial for actions beyond their role.
  • Policy enforcement in CI/CD pipelines that scans for unprotected routes or bypasses of the standard authorization layer.

Sources

SourceLink
github.comgithub.com/teableio/teable/pull/3285
github.comgithub.com/teableio/teable/releases/tag/release.2026-06-15T04-43-24Z.1912
vulncheck.comvulncheck.com/advisories/teable-missing-authorization-in-v2-rest-api

Frequently asked

questions

No. Exploitation generally requires an authenticated account, but any valid user—even with minimal privileges—can abuse the unprotected endpoints.

Not necessarily full administrative control, but it can grant extensive data access and modification capabilities across bases and tables, which may be equivalent to admin-level impact in many deployments.

Ensure all ORPC and REST endpoints that access or modify tables and records are protected by a centralized authorization layer, using explicit permission annotations or middleware that performs resource- and role-based checks.

Adopt a secure-by-default API design where no endpoint is exposed without an explicit authorization strategy, enforce framework-level requirements for permission metadata, and integrate automated checks and code review guidelines focused on access control.

Find out what's already
exploitable in your codebase.