/

CVE-2026-32097

Severity:

HIGH RISK

(8.8)

Broken Access Control / Insecure Direct Object Reference

CVE-2026-32097

Analyzed

Vulnerability type

Category:

Broken Access Control / Insecure Direct Object Reference

CWE:

CWE-639

Impact:

Unauthorized Data Access and Deletion

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

An authorization flaw in PingPong before version 7.27.2 allows authenticated users to retrieve or delete files outside their intended authorization scope.

Under specific conditions, a user who can access at least one thread may be able to access or remove private files belonging to other users, including uploaded content and model-generated outputs.

Affected context

The vulnerability affects PingPong deployments where file access and deletion are tied to thread participation but object-level authorization checks are incomplete or inconsistently enforced.

It manifests in contexts where authenticated users interact with files attached to discussion threads or LLM sessions, and the system relies on user-controlled identifiers or indirect references without robust validation that the requesting user actually owns or is permitted to access the underlying file resource.

Exploit preconditions

  • Attack surface: Web application endpoints responsible for file retrieval and file deletion.
  • Required access: Valid authenticated account.
  • Additional permissions:
  • For file retrieval: permission to view at least one thread.
  • For file deletion: permission to participate in at least one thread.
  • Trigger point: Issuing crafted requests to file-related endpoints that reference files associated with other users or threads.
  • Why exploitation is possible: The application enforces access control at a coarse level (e.g., "is authenticated" and "has some thread access") but does not consistently verify that the requesting user is authorized for the specific file ID or resource being retrieved or deleted, allowing horizontal privilege escalation.

Why this happens

This vulnerability stems from improper enforcement of authorization checks on a per-object basis, matching CWE-639: Insecure Direct Object Reference (IDOR) for authorization.

The system appears to expose file identifiers or references in a way that allows an authenticated user with minimal thread access to interact with files that are not bound to their own account or authorized context.

Instead of verifying that the user requesting an operation on a given file is specifically allowed to view or delete that file, the implementation likely relies on weaker checks such as "is authenticated" and "is associated with some thread," leaving gaps in the mapping between user, thread, and file ownership/permissions.

Potential impact

  • Unauthorized retrieval of private user-uploaded files.
  • Unauthorized retrieval of model-generated output files that may contain sensitive or proprietary content.
  • Unauthorized deletion of files belonging to other users or threads.
  • Loss of important learning or teaching materials, including assessments and instructional content.
  • Exposure of confidential information that could lead to privacy breaches or intellectual property leakage.
  • Erosion of trust in the platform due to apparent cross-user data access.

General mitigation guidance

Effective mitigation focuses on enforcing strict, explicit object-level authorization for all file operations and decoupling trust from user-controlled identifiers:

  • Implement per-file access control checks that verify the requesting user (or their role) is explicitly authorized to view or delete the specific file, based on ownership or well-defined sharing rules.
  • Treat all file identifiers and references as untrusted input; never assume that an authenticated user is entitled to act on arbitrary IDs.
  • Centralize authorization logic for file resources so that all endpoints (download, preview, delete, export, etc.) use the same vetted policy and checks.
  • Use strong binding between files and their parent entities (threads, courses, classes, organizations) and always validate that the user's relationship to that parent entity grants the requested file permission.
  • Apply the principle of least privilege in role and permission design, ensuring that thread participation does not implicitly grant global file access.
  • Log and regularly review file access and deletion events to support auditability and rapid detection of anomalous cross-user operations.

How teams detect issues like this

Detection generally relies on a combination of code-centric review and behavioral monitoring:

  • Static analysis and code review:
  • Search for file access and deletion endpoints that accept file IDs, paths, or tokens and confirm that each path enforces ownership or ACL checks.
  • Flag controller or service methods where authorization checks only confirm authentication or generic role membership without tying access to the specific file's metadata.
  • Review any places where file paths or identifiers are derived from user-controllable input without corresponding permission validation.
  • Policy and testing:
  • Define security test cases that attempt to access or delete files belonging to other users using modified IDs or URLs (negative test cases for horizontal access control).
  • Use automated security testing tools to fuzz file-related endpoints with IDs from various accounts.
  • Runtime monitoring:
  • Instrument logging around file access and deletion, including user ID, file ID, and parent context (thread, course, or group), and alert on anomalous patterns such as one user accessing many unrelated users' files.
  • Periodically sample logs to verify that cross-tenant or cross-user access is limited to explicitly allowed scenarios (e.g., instructor roles).

Sources

SourceLink
github.comgithub.com/comppolicylab/pingpong/security/advisories/GHSA-4wwr-5wq7-mgm4

Frequently asked

questions

Exploitation is limited to authenticated users with at least some thread access, but within that scope it can enable horizontal privilege escalation, allowing one user to access or delete files that belong to others if they can manipulate file references or identifiers.

An attacker must have a valid account on the PingPong platform. To exploit retrieval, they need permission to view at least one thread; to exploit deletion, they need permission to participate in at least one thread. No elevated administrator privileges are required.

The most robust fix is to enforce strict object-level authorization for every file operation, ensuring that for each request the system checks whether the authenticated user is explicitly authorized to view or delete the targeted file based on ownership or well-defined sharing rules, rather than relying only on general thread access.

Adopt a consistent access control model that treats all resource identifiers as untrusted, centralize authorization checks in reusable components, mandate code review for any new endpoints that expose direct resource access, and incorporate automated tests that attempt cross-user file access to catch IDOR-style flaws early in the development lifecycle.

Find out what's already
exploitable in your codebase.