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).

