/

CVE-2026-24901

Severity:

HIGH RISK

(8.1)

Insecure Direct Object Reference (IDOR) in Outline Draft

CVE-2026-24901

Analyzed

Vulnerability type

Category:

Insecure Direct Object Reference (IDOR)

CWE:

CWE-639

Impact:

Unauthorized Data Access and Privilege Misuse

Severity:

HIGH RISK

(8.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

An Insecure Direct Object Reference (IDOR) vulnerability in Outline's document restoration logic allows any team member to restore and take ownership of deleted drafts belonging to other users, including administrators.

By bypassing ownership validation during the restore operation, an attacker can view sensitive content from private drafts and prevent the original owner from accessing or controlling their own material.

Affected context

This vulnerability manifests in Outline instances where team members can restore deleted drafts without proper ownership checks being enforced.

It most commonly appears in collaborative environments where drafts can be soft-deleted or moved to a trash state and later restored.

The issue relies on the application trusting a client-provided identifier for the draft during restoration, without revalidating whether the requesting user actually owns that draft or is otherwise authorized to restore it.

Exploit preconditions

  • Attack surface: Web application endpoints responsible for restoring deleted drafts.
  • Required access: Valid authenticated account within the Outline team (any team member, not necessarily privileged).
  • Trigger point: Invocation of the draft-restore operation using an identifier for a draft owned by another user (including administrators).
  • Why exploitation is possible: The restore logic does not correctly enforce ownership or authorization checks on the referenced draft, allowing users to act on objects they do not own by directly referencing their identifiers.

Why this happens

The underlying bug is a classic Insecure Direct Object Reference (CWE-639), where access control is tied only to object identifiers supplied by the client rather than contextual authorization checks.

In the draft restoration workflow, the server accepts a draft ID and performs the restore operation without reliably verifying that the authenticated user is the rightful owner or has sufficient permissions over that specific draft.

This missing or incomplete authorization step creates a gap between authentication and object-level access control, allowing users to operate on resources outside their legitimate scope.

Potential impact

  • Unauthorized restoration and viewing of private drafts belonging to other team members or administrators.
  • Exposure of sensitive information contained in drafts that were believed to be private or safely deleted.
  • Seizure of ownership over another user's content, potentially locking them out of their own material.
  • Erosion of trust in the collaboration platform due to unpredictable access boundaries.
  • Regulatory or contractual issues if confidential or regulated data is exposed to unauthorized internal users.

General mitigation guidance

Effective mitigation focuses on enforcing robust, server-side authorization for all object-level operations and eliminating reliance on client-supplied identifiers alone.

Common defensive patterns include:

  • Implementing strict ownership and permission checks before restoring any draft, based on the authenticated user's identity and role.
  • Using a centralized authorization layer or policy engine so that all resource access decisions follow consistent rules.
  • Designing APIs so that object references are validated against the current user's accessible resource set, rather than blindly trusting an arbitrary ID.
  • Applying the principle of least privilege by limiting which users can restore documents and which scopes they can act upon.
  • Treating "soft-deleted" and archived items with the same access control rigor as active content, ensuring that deletion state does not bypass security checks.

How teams detect issues like this

Organizations can detect and prevent similar IDOR issues through a combination of design review and automated analysis.

Useful approaches include:

  • Security-focused code review of all endpoints that accept resource identifiers, verifying that they consistently enforce ownership and permission checks.
  • Static analysis rules that flag direct use of client-supplied IDs in database queries or repository methods without adjacent authorization logic.
  • Centralized logging of restore and access events, with anomaly detection for unusual patterns (e.g., one user restoring many drafts owned by others).
  • Integration of automated security testing tools (such as API fuzzers or DAST scanners) that attempt to access or manipulate resources across user boundaries.

Sources

SourceLink
github.comgithub.com/outline/outline/security/advisories/GHSA-gmr5-43f5-79f5

Frequently asked

questions

Yes, if the Outline instance is reachable over the internet. However, exploitation still requires an authenticated account within the affected team; anonymous users cannot exploit the issue directly.

The attacker needs to be a legitimate team member with valid login credentials. Administrator privileges are not required; any authenticated user who can interact with the draft restoration functionality can potentially exploit the flaw.

The safest pattern is to enforce strict, server-side authorization checks on every operation that involves object identifiers. For draft restoration, this means ensuring that the authenticated user either owns the draft or has an explicit permission that allows restoring it, before performing any action.

Prevention typically involves adopting a consistent access control model, centralizing authorization logic, and making object-level permission checks a standard requirement for all CRUD and restore operations. Regular security code reviews, security testing in CI, and using established access control frameworks can all help avoid reintroducing this class of vulnerability.

Find out what's already
exploitable in your codebase.