/

CVE-2026-25810

Severity:

CRITICAL RISK

(9.1)

Missing Authorization / Access Control in PlaciPy Student

CVE-2026-25810

Analyzed

Vulnerability type

Category:

Missing Authorization / Access Control

CWE:

CWE-862

Impact:

Horizontal Privilege Escalation and Data Exposure

Severity:

CRITICAL RISK

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

PlaciPy 1.0.0 contains a missing authorization flaw in backend/src/routes/student.submission.routes.ts where authentication is verified but per-object ownership checks are not enforced.

As a result, an authenticated user may be able to access or manipulate submission records that belong to other students whenever they can influence identifiers or query parameters used by these routes.

Affected context

The vulnerability affects PlaciPy deployments where the student submission routes rely solely on authentication to grant access to submission-related operations.

The routes in backend/src/routes/student.submission.routes.ts appear to trust identifiers from the request (such as submission IDs or student IDs) without consistently verifying that the authenticated user is the legitimate owner of the referenced resource.

This issue typically arises in multi-tenant or multi-user educational environments where different students and institutions share the same backend API.

Exploit preconditions

  • Attack surface: HTTP API endpoints defined in student.submission.routes.ts.
  • Required access: Valid authenticated user account (e.g., any student login).
  • Trigger point: Supplying identifiers (IDs, parameters, or path segments) that reference another student's submission or related resource.
  • Why exploitation is possible: The route handlers verify user authentication but do not perform object-level authorization checks such as comparing the authenticated user's identifier with the owner field of the targeted submission.

Why this happens

This vulnerability is an instance of CWE-862: Missing Authorization, where the system verifies that a user is logged in but fails to enforce whether that user is allowed to access a specific object.

In the affected routes, the backend likely performs operations (read, update, delete, or list submissions) based solely on request parameters and the fact that a session or token is valid.

There is no consistent authorization layer confirming that the submission being accessed actually belongs to the authenticated student or that the user has an appropriate role for the operation.

The underlying pattern is a missing or incomplete access-control decision at the object level, a common issue when authentication middleware is added but fine-grained authorization logic is not centrally enforced.

Potential impact

  • Authenticated students could view other students' submission details and associated metadata.
  • Attackers could modify, overwrite, or delete other students' submissions, affecting grades or placement outcomes.
  • Sensitive information (such as project content, personal details linked to submissions, or evaluation comments) could be exposed.
  • Integrity of placement data and academic records could be compromised across the institution's deployment.

General mitigation guidance

Effective mitigation focuses on introducing consistent, centralized authorization checks for all submission-related routes.

Recommended defensive patterns include:

  • Enforcing object-ownership checks on every operation that takes a submission or student identifier, ensuring that the authenticated user's identity matches the resource owner.
  • Implementing role- and scope-based access control, where actions on submissions are tied to explicit roles (e.g., student, faculty, admin) and cannot be inferred solely from being authenticated.
  • Encapsulating authorization logic in reusable middleware or service-layer helpers so it cannot be accidentally omitted in new routes.
  • Limiting the fields and identifiers that clients can control, and deriving sensitive identifiers from the authenticated context where possible rather than trusting request input.
  • Applying the principle of least privilege so that users are only granted permissions strictly necessary for their role.

How teams detect issues like this

Detecting missing authorization is typically achieved through a combination of code-level review, policy enforcement, and testing:

  • Static analysis and code review: Look for routes that:
  • Only check for authentication (e.g., presence of a token or session) but do not verify ownership or role.
  • Use request parameters (e.g., req.params.id, req.body.studentId) directly to query submissions without comparing them against the authenticated user's ID.
  • Authorization policy enforcement: Define coding standards that require an explicit authorization check for every route that accesses user- or tenant-specific data, and enforce these rules in code review.
  • Automated tests: Develop negative tests where one authenticated student attempts to access or modify another student's submissions and ensure access is denied.
  • Runtime monitoring: Log access-control decisions and unexpected cross-user access patterns to help identify potential authorization gaps in production.

Sources

SourceLink
github.comgithub.com/Praskla-Technology/assessment-placipy/security/advisories/GHSA-2gqv-gxrj-p8x3

Frequently asked

questions

The issue can typically be exploited by any authenticated user who can guess or obtain identifiers for other students' submissions. It does not require elevated roles; a basic student account may be enough if the routes lack ownership checks.

No. The flaw is in missing object-level authorization, so a regular authenticated user account is usually sufficient, provided the attacker can manipulate request parameters to reference other users' resources.

Introduce a consistent authorization layer that verifies ownership and roles for every submission-related operation. Route handlers should derive the acting user from the authenticated context and confirm that the targeted submission belongs to that user or that their role explicitly permits cross-user access.

Adopt a defense-in-depth approach to access control: design and document a clear authorization model, centralize authorization checks in reusable middleware or services, enforce coding standards through code review and automated tools, and include cross-user access tests as part of the standard test suite.

Find out what's already
exploitable in your codebase.