/

CVE-2026-25875

Severity:

CRITICAL RISK

(9.8)

Improper Authorization in PlaciPy Placement Management

CVE-2026-25875

Analyzed

Vulnerability type

Category:

Improper Authorization

CWE:

CWE-863

Impact:

Privilege Escalation to Administrative Functions

Severity:

CRITICAL RISK

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

PlaciPy 1.0.0 trusts client-supplied JWT claims such as role and scope in its admin authorization middleware without enforcing server-side role verification.

An attacker who can craft or manipulate JWTs may obtain unauthorized administrative capabilities, potentially accessing or modifying sensitive placement data and student records.

Affected context

This vulnerability arises in deployments of PlaciPy 1.0.0 where JSON Web Tokens (JWTs) are used for access control and the admin middleware directly relies on the role and scope claims present in the token.

It becomes most relevant when:

  • Tokens can be generated or modified by clients (e.g., weak signing, shared secrets, or missing signature checks).
  • The server does not independently verify user roles or permissions against a trusted backend store.
  • Administrative endpoints make decisions based solely on JWT claims without additional validation.

Exploit preconditions

  • Attack surface: HTTP(S) endpoints protected by PlaciPy's admin authorization middleware.
  • Required access: Ability to present a JWT to the application (e.g., any authenticated or semi-authenticated user, or anyone who can forge/sign tokens if verification is weak).
  • Trigger point: Sending requests to privileged routes while supplying a JWT whose role or scope values are elevated (e.g., admin) or broadened.
  • Why exploitation is possible: The middleware implicitly trusts the role and scope claims embedded in the JWT and does not cross-check them against a server-side authority, allowing clients to self-assign privileges.

Why this happens

The core issue is an authorization design flaw where the server uses client-provided claims as the source of truth for permissions.

Instead of treating JWT claims as untrusted input requiring validation, the middleware directly maps fields like role and scope to authorization decisions.

This behavior corresponds to CWE-863: Improper Authorization, where the system fails to enforce proper authorization checks and allows users to act with more privileges than intended.

Conceptually, this is a conflation of authentication (who the user is) and authorization (what the user is allowed to do), with the latter incorrectly delegated to mutable client-side data.

Potential impact

  • Attackers may gain administrative access to PlaciPy's management interface.
  • Unauthorized modification or deletion of placement records, student profiles, or organization data may occur.
  • Exposure of sensitive student, recruiter, or placement information can happen.
  • Attackers could manipulate configuration or workflow settings, impacting institutional operations.
  • Audit trails and logs may be tampered with, obscuring malicious activities.

General mitigation guidance

Effective mitigation focuses on enforcing server-side authorization and treating JWT claims as hints, not authoritative facts:

  • Derive effective roles and permissions from a trusted server-side data store (e.g., database, directory service) using the user's stable identifier from the token, rather than trusting role or scope directly.
  • Implement a central authorization layer that evaluates access based on server-maintained role/permission mappings and contextual checks (e.g., tenant, ownership, status).
  • Use strict, minimal JWT contents: limit claims to identifiers and non-privileged metadata; avoid placing critical authorization decisions entirely in client-controllable claims.
  • Apply least-privilege principles so that the default effective role is always non-administrative unless explicitly granted server-side.
  • Consider including token-bound constraints (e.g., audience, issuer, expiry) and ensure they are verified consistently to reduce token misuse.

How teams detect issues like this

Detection should aim to reveal authorization decisions that directly rely on client-controlled claims:

  • Use static analysis or code search to find middleware and route handlers that read JWT role, scope, or similar claims and make access decisions without consulting a server-side permission store.
  • During code review, flag patterns where authorization checks are implemented solely via token claims rather than via dedicated authorization services or modules.
  • Implement security unit and integration tests that simulate tokens with forged or altered roles/scopes to ensure access is denied when server-side data does not grant those privileges.
  • Employ runtime monitoring and logging to detect unusual patterns such as non-admin accounts invoking admin-only endpoints, and correlate with underlying token contents.
  • Consider automated policy enforcement (e.g., OPA/Rego, centralized RBAC/ABAC engines) to ensure that authorization logic is declarative and auditable.

Sources

SourceLink
github.comgithub.com/Praskla-Technology/assessment-placipy/security/advisories/GHSA-mx95-8ppg-v574

Frequently asked

questions

Yes. Any remote client capable of presenting a JWT to the application may attempt to exploit this flaw by manipulating the role or scope claims, subject to how tokens are generated and verified.

Typically, the attacker needs the ability to obtain or create JWTs recognized by the application.

If token signing is weak or misconfigured, they may be able to forge tokens; otherwise, even a low-privileged authenticated user may exploit the issue by modifying claims in their existing token if signature checks are absent or bypassed.

The most robust fix is to centralize authorization on the server side: use the user's identity from the JWT to look up roles and permissions in a trusted store and base all access decisions on that server-side data, ignoring or strictly constraining privilege-related claims from the token.

Design the system so that authentication and authorization are clearly separated, treat all client-supplied data (including token claims) as untrusted, use standardized RBAC/ABAC frameworks, and enforce secure coding guidelines and reviews focused on access control logic.

Find out what's already
exploitable in your codebase.