/

CVE-2026-25812

Severity:

HIGH RISK

(8.8)

CSRF in PlaciPy Placement Management System

CVE-2026-25812

Analyzed

Vulnerability type

Category:

Cross-Site Request Forgery (CSRF)

CWE:

CWE-352

Impact:

Unauthorized state-changing actions via victim's browser

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

PlaciPy 1.0.0 enables credentialed CORS requests but omits any cross-site request forgery (CSRF) protection, allowing browsers to automatically include authentication cookies on cross-origin requests.

If a logged-in user visits a malicious site, that site could silently trigger state-changing actions in PlaciPy on the user's behalf, potentially compromising placement records and administrative workflows.

Affected context

This vulnerability occurs in PlaciPy 1.0.0 deployments where:

  • Users authenticate via browser-based sessions or cookies
  • Cross-Origin Resource Sharing (CORS) is configured to allow credentialed requests
  • State-changing endpoints (e.g., record creation, updates, approvals) accept requests without CSRF validation

In such setups, the browser will attach valid authentication credentials to cross-origin requests, even when they originate from a different, potentially malicious website.

Exploit preconditions

  • Attack surface: Web application endpoints exposed via HTTP(S), including those accessible cross-origin under the configured CORS policy.
  • Required access: Attacker must lure a victim who is currently authenticated (or whose session is still valid) into visiting a malicious webpage they control.
  • Trigger point: The malicious page issues crafted HTTP requests (e.g., POST, PUT, DELETE) to PlaciPy endpoints, leveraging the browser's automatic inclusion of cookies or credentials.
  • Why exploitation is possible: PlaciPy accepts state-changing requests solely based on the browser's authentication state and permitted CORS configuration, without any CSRF token, same-site defense, or equivalent anti-forgery validation, allowing cross-origin sites to drive actions as the victim.

Why this happens

The root cause aligns with CWE-352: Cross-Site Request Forgery (CSRF). PlaciPy relies on browser-managed credentials for authentication but does not bind state-changing requests to a user-initiated, origin-verified action.

By allowing credentialed CORS without overlaying CSRF defenses, the application treats any request carrying valid cookies as trustworthy, regardless of its true origin or the user's intent. This missing verification step creates an insecure pattern where the authentication mechanism is decoupled from request provenance and user consent.

Potential impact

  • An attacker could trigger unauthorized changes to placement records, such as creating, modifying, or deleting student or company entries.
  • Administrative actions (approvals, rejections, slot allocations) could be performed in the name of privileged users.
  • User account settings or preferences might be altered without the user's knowledge.
  • Integrity of placement data and reporting could be undermined, leading to incorrect or fraudulent placement outcomes.
  • In multi-role environments, compromise of a highly privileged user's browser session could enable wide-scale data tampering.

General mitigation guidance

Effective mitigation typically combines multiple CSRF defenses to ensure state-changing requests are both authenticated and verified as intentional:

  • Implement a synchronizer token pattern or equivalent anti-CSRF token in all state-changing forms and AJAX calls, ensuring tokens are unique per session and validated server-side.
  • Prefer SameSite cookies (e.g., SameSite=Lax or Strict where compatible) to restrict automatic cookie inclusion on cross-site requests.
  • Apply the principle of least privilege to CORS by limiting allowed origins, disallowing wildcard origins with credentials, and restricting methods and headers to what is strictly necessary.
  • Enforce that sensitive endpoints require non-idempotent methods (POST/PUT/DELETE) combined with CSRF checks, rather than accepting state changes via GET requests.
  • Design APIs so that high-risk actions require explicit user interaction (re-authentication, step-up verification, or confirmation workflows), reducing the impact of automated CSRF attempts.

How teams detect issues like this

Detection generally focuses on identifying missing CSRF controls and risky CORS configurations:

  • Static analysis and code review:
  • Flag state-changing routes that rely solely on session cookies or bearer tokens from browsers without validating anti-CSRF tokens or origin headers.
  • Look for controllers or views that process POST/PUT/DELETE actions without a corresponding CSRF middleware, decorator, or filter.
  • Review CORS configuration for Access-Control-Allow-Credentials: true combined with broad Access-Control-Allow-Origin patterns.
  • Dynamic testing:
  • Use web security testing tools or manual scripts to send cross-origin requests from a controlled origin and observe whether state changes occur without CSRF defenses.
  • Validate that preflight CORS responses for sensitive endpoints are not overly permissive.
  • Security policy enforcement:
  • Adopt organization-wide guidelines requiring CSRF protection on all browser-exposed, session-based endpoints.
  • Integrate automated checks in CI/CD to ensure CSRF middleware is enabled and CORS policies conform to approved patterns.

Sources

SourceLink
github.comgithub.com/Praskla-Technology/assessment-placipy/security/advisories/GHSA-99xx-fc63-wc39

Frequently asked

questions

Yes. An attacker can exploit it remotely by hosting a malicious webpage and convincing authenticated PlaciPy users to visit it. The attack executes through the victim's browser, not by directly breaching the server.

The attacker does not need their own credentials but relies on the victim's existing authenticated session. As long as the victim is logged in (or has an active session), the browser will attach the necessary credentials to cross-origin requests.

Introduce robust CSRF protections for all state-changing endpoints, typically via a well-tested framework feature or middleware that issues and verifies anti-CSRF tokens, alongside stricter CORS and cookie configurations (e.g., SameSite cookies and limited allowed origins).

Treat CSRF protection as a default requirement for any web application that uses browser-managed credentials, adopt secure CORS-by-default patterns, regularly review authentication and session handling design, and enforce CSRF and CORS checks through coding standards and automated security testing.

Find out what's already
exploitable in your codebase.