/

CVE-2026-33330

Severity:

HIGH RISK

(7.1)

Broken Access Control in FileRise ONLYOFFICE Integration

CVE-2026-33330

Analyzed

Vulnerability type

Category:

Broken Access Control

CWE:

CWE-863

Impact:

Unauthorized File Modification and Data Integrity Violation

Severity:

HIGH RISK

(7.1)

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

A broken access control flaw in FileRise's ONLYOFFICE integration allows a user with read-only access to obtain a signed save callback URL for a document.

By reusing this callback URL, the user can forge an ONLYOFFICE save callback and overwrite the original file with attacker-controlled content, despite not having write permissions.

Affected context

This vulnerability arises in FileRise instances that:

  • Are self-hosted and expose the ONLYOFFICE integration for document editing
  • Allow authenticated users to access documents in a read-only role
  • Use signed callback URLs for ONLYOFFICE save operations without binding them strictly to user permissions or operation intent

In such setups, the save callback endpoint accepts updates based solely on possession of a valid signed URL, rather than re-checking whether the caller has write access to the target file.

Exploit preconditions

  • Attack surface: FileRise web interface and its ONLYOFFICE integration endpoints.
  • Required access: Authenticated account with at least read-only access to the target file.
  • Trigger point: The attacker obtains a signed ONLYOFFICE save callback URL for a file and then directly invokes the save callback endpoint with attacker-controlled document content.
  • Why exploitation is possible: The authorization decision for write operations is effectively delegated to the possession of a signed callback URL, without robust server-side enforcement of the user's actual permissions at the time the save callback is processed.

Why this happens

The core issue is an authorization flaw aligning with CWE-863: Incorrect Authorization, where the system fails to correctly enforce access control for a protected operation.

FileRise's ONLYOFFICE integration relies on a signed save callback URL as a proof that the write operation is allowed, but does not sufficiently tie that authorization to the user's current permissions or role (e.g., read-only vs. read-write).

As a result, any user who can cause or observe generation of a valid save callback URL for a file can bypass intended write restrictions by calling the callback endpoint directly with crafted content.

This pattern reflects a broader class of broken access control issues in which integrity-critical operations are authorized based on bearer-style tokens or URLs alone, instead of revalidating permissions at the time of the state-changing request.

Potential impact

  • An attacker with nominally read-only access can overwrite existing documents with arbitrary content.
  • Sensitive or business-critical files can be corrupted, defaced, or replaced with malicious payloads (e.g., macro-enabled office documents).
  • Data integrity guarantees within shared workspaces can be undermined, complicating audits and change tracking.
  • Users and automated processes consuming the modified documents may act on falsified or tampered information.
  • In environments where documents are further distributed or synced, the malicious changes can propagate to downstream systems.

General mitigation guidance

Mitigation generally focuses on tightening authorization checks around document save operations and reducing reliance on bearer-style URLs for integrity-sensitive actions.

Recommended defensive patterns include:

  • Re‑enforce access control on callbacks: Ensure the ONLYOFFICE save callback handler revalidates the user's current permissions (e.g., read vs. write) using session, token, or server-side context, rather than trusting the callback URL alone.
  • Bind tokens to authorization context: When using signed URLs, bind them to specific users, roles, and operations (e.g., "edit" vs. "view") and reject use if the current context does not match.
  • Use short‑lived and single‑use tokens: Limit the lifetime of callback signatures and consider making them single-use to reduce replay risk.
  • Separate read and write endpoints: Architect the integration so that read-only flows never obtain or interact with write-capable callbacks.
  • Enforce least privilege: Ensure default and common roles are read-only unless write access is explicitly justified and approved.
  • Improve logging and integrity checks: Maintain detailed logs and, where feasible, use content hashing or versioning to detect unexpected overwrites.

How teams detect issues like this

Detecting this class of access control flaws typically involves both design-level review and runtime monitoring:

  • Code review focus: Examine the ONLYOFFICE integration code for endpoints that modify file content and verify that:
  • Authorization checks are performed at the time of the write operation.
  • Signed URLs or tokens are not treated as sole proof of authorization.
  • Read-only roles cannot reach code paths that perform file writes.
  • Static analysis patterns: Use static analysis or SAST tools to flag:
  • State-changing handlers that do not perform explicit permission checks.
  • Endpoints that rely entirely on bearer-style tokens or URL signatures for authorization.
  • Security architecture reviews: Evaluate third-party integrations (like ONLYOFFICE) to ensure their callbacks and webhooks are subject to the same access control policies as first-party endpoints.
  • Runtime monitoring: Configure application logs and SIEM alerts to detect anomalies such as:
  • Read-only users invoking document save callbacks.
  • Unexpected write operations from accounts or IPs that rarely perform edits.
  • Automated policy checks: Incorporate authorization policy testing into CI/CD to validate that users with read-only roles cannot trigger write or update APIs under any integration paths.

Sources

SourceLink
github.comgithub.com/error311/FileRise/commit/3871f9fd1661688bed4f7dd23912be0ebf50973c
github.comgithub.com/error311/FileRise/releases/tag/v3.10.0
github.comgithub.com/error311/FileRise/security/advisories/GHSA-6c3j-f4x4-36m3

Frequently asked

questions

Yes. Any authenticated user who can access the FileRise web interface and interact with documents via ONLYOFFICE can potentially exploit this issue, provided they can obtain a valid save callback URL. The exploitation occurs over standard HTTP(S) requests.

The attacker must have a valid account and at least read-only access to the target file. No elevated administrative privileges are required; the flaw specifically enables users with limited rights to perform unauthorized write operations.

The safest approach is to ensure that all file write operations, including those invoked through ONLYOFFICE callbacks, perform robust server-side authorization checks tied to the current user and their role. Signed callback URLs should not be treated as sufficient proof of write permission; instead, they should be one component in a broader, context-aware authorization decision.

Prevention involves designing integrations under a "never trust the client" and "re-check on modification" mindset:

  • Require explicit permission checks on every state-changing endpoint.
  • Avoid granting write-capable tokens or URLs to read-only flows.
  • Regularly perform access control reviews and threat modeling on external integrations and callback mechanisms.
  • Add automated tests to verify that users with read-only roles cannot trigger any write, update, or delete behavior, regardless of integration paths.
Find out what's already
exploitable in your codebase.