/

CVE-2026-25876

Severity:

CRITICAL RISK

(9.1)

Missing Authorization / Access Control in PlaciPy Results

CVE-2026-25876

Analyzed

Vulnerability type

Category:

Missing Authorization / Access Control

CWE:

CWE-862

Impact:

Unauthorized Data Access and Privacy Violation

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 verifies that a user is authenticated before accessing results, but fails to enforce object-level authorization on the results endpoint.

This means any logged-in user may be able to access result records for assessments they do not own or should not see, potentially exposing sensitive academic information at scale.

Affected context

The vulnerability occurs in the PlaciPy backend, specifically in backend/src/routes/results.routes.ts, where authentication is checked but fine-grained authorization is not.

It manifests when endpoints that return assessment results do not verify that the requesting user is permitted to view each result record (e.g., ownership, role, or institutional scope).

In typical deployments, this affects multi-user environments where students, staff, or administrators share the same application backend and rely on access control to keep assessment data compartmentalized.

Exploit preconditions

  • Attack surface: HTTP(S) API endpoints handling assessment results.
  • Required access: Valid authenticated account on the PlaciPy system (e.g., any student, staff, or generic user).
  • Trigger point: Issuing requests to results-related routes, optionally manipulating identifiers (IDs, query parameters) to reference other users' assessments or bulk data.
  • Why exploitation is possible: The route enforces authentication but does not perform object-level authorization checks, so the backend trusts that any authenticated user is allowed to access the requested result set without verifying ownership or scope.

Why this happens

The underlying issue is a classic missing authorization flaw as described by CWE-862.

While the application correctly verifies that a request comes from an authenticated user, it does not evaluate whether that user is allowed to access the specific result objects being requested.

Concretely, the route logic in results.routes.ts likely:

  • Accepts parameters (such as assessment IDs, user IDs, or filters) from the client.
  • Queries the database for matching result records.
  • Returns the results without adding a filter that ties the records to the authenticated user's identity, role, or institution context.

This pattern turns what should be object-bound access control into a coarse "logged-in vs. not logged-in" check, leaving fine-grained authorization entirely absent.

Potential impact

  • Exposure of all results for a given assessment to any authenticated user.
  • Unauthorized access to individual students' performance data and potentially sensitive personal information.
  • Ability to enumerate and aggregate large volumes of academic records across classes, departments, or institutions.
  • Violation of privacy regulations and institutional data protection policies.
  • Loss of trust in the placement management system and potential reputational damage for the institution.

General mitigation guidance

Effective mitigation focuses on introducing consistent, object-level authorization checks wherever results are accessed or manipulated:

  • Implement authorization middleware or helper functions that enforce ownership or role-based checks for each result and assessment resource.
  • Ensure database queries are always constrained by the authenticated user's identity and allowed scope (e.g., tenant ID, institution ID, role), not just by client-supplied identifiers.
  • Centralize authorization rules so that routes cannot bypass them, applying a "secure by default" pattern where access is denied unless explicitly granted.
  • Use role-based access control (RBAC) or attribute-based access control (ABAC) to define which roles (student, faculty, admin) can access which categories of results.
  • Minimize exposure of bulk endpoints that return large sets of sensitive records unless strictly necessary, and apply stronger authorization and auditing to those endpoints.

How teams detect issues like this

Teams can identify and monitor for missing authorization issues through several complementary approaches:

  • Code review: Look for routes that:
  • Check authentication (e.g., isAuthenticated middleware) but do not check that returned records belong to the current user or their allowed scope.
  • Accept resource identifiers from the client without cross-checking them against the authenticated user context.
  • Static analysis: Configure rules that flag:
  • Direct database queries on sensitive tables (e.g., results, assessments, users) that lack filters referencing the authenticated user or tenant.
  • Usage of result retrieval functions in routes that are not wrapped in authorization checks.
  • Security testing: Perform access control testing by:
  • Logging in as a low-privilege user and attempting to access other users' results via ID manipulation or parameter changes.
  • Probing bulk endpoints to see if they return more data than expected.
  • Runtime monitoring: Log and analyze access patterns, including:
  • Requests that return unusually large result sets.
  • Repeated access from a low-privilege account to data spanning multiple users or departments.

Sources

SourceLink
github.comgithub.com/Praskla-Technology/assessment-placipy/security/advisories/GHSA-w238-w4mg-j357

Frequently asked

questions

Yes. Any user who can reach the PlaciPy backend and authenticate (e.g., via the web UI or API) can potentially exploit the missing authorization in the results endpoint, without needing local access to the server.

No. A standard, low-privilege account is typically sufficient. The issue stems from the absence of object-level authorization, so simply being authenticated may grant access to other users' results.

Introduce consistent, centralized authorization checks that validate the caller's right to access each result or assessment. Database queries should be constrained by the authenticated user's identity and allowed scope, and routes should fail closed when authorization cannot be established.

Design access control as a first-class concern: define clear authorization rules for each resource, enforce them via shared middleware or services, incorporate access control tests into your QA process, and augment code review and static analysis to flag any route that accesses sensitive data without explicit authorization checks.

Find out what's already
exploitable in your codebase.