/

CVE-2026-25753

Severity:

CRITICAL RISK

(9.8)

Hard-Coded Credentials in PlaciPy Student Account Creation

CVE-2026-25753

Analyzed

Vulnerability type

Category:

Hard-Coded Credentials

CWE:

CWE-259

Impact:

Mass Account Takeover

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 uses a single hard-coded default password for all newly created student accounts, creating identical credentials across the user base.

Once this static password becomes known, an attacker can log in as any student, enabling mass account takeover without needing to guess or reset individual passwords.

Affected context

This vulnerability affects PlaciPy deployments where student accounts are provisioned with a fixed, hard-coded default password instead of unique, user-specific secrets.

It typically occurs during automated account creation workflows (e.g., bulk onboarding of students) when the application does not enforce password selection or change on first login.

The issue is most severe in environments where the default password is shared verbally, documented, or guessable, and where student accounts have access to sensitive academic or personal data.

Exploit preconditions

  • Attack surface: Public-facing PlaciPy login interface (web or portal UI)
  • Required access: Ability to reach the login page; no prior authentication needed
  • Trigger point: Submitting any valid student identifier (e.g., username, email, student ID) with the static default password
  • Why exploitation is possible: The system assigns the same hard-coded password to all new student accounts and does not enforce a password change on first use, so knowledge of the single default password grants access to every such account.

Why this happens

The underlying problem is the use of a hard-coded, static password for all accounts in a given category, which maps directly to CWE-259: Use of Hard-coded Password.

Instead of generating or requiring unique secrets per student, the implementation relies on a shared credential embedded in configuration or code.

Because that credential never changes during account provisioning and is not bound to any individual user or device, compromise of this single value compromises the entire student user population.

Potential impact

  • Attacker may take over any or all student accounts once the default password is known.
  • Attacker could access or manipulate student placement data, applications, and personal information.
  • Attacker may impersonate students in communications or workflows related to internships, jobs, or academic records.
  • Attacker could disrupt placement processes by modifying or deleting applications and preferences.
  • Attacker may use compromised accounts as a foothold for further attacks against staff or administrative systems (e.g., phishing from trusted accounts).

General mitigation guidance

Effective mitigation focuses on eliminating shared, hard-coded credentials and enforcing strong, individualized authentication:

  • Replace hard-coded default passwords with per-account, randomly generated credentials that are delivered over a secure channel or set by the user during onboarding.
  • Enforce a mandatory password change on first login, preventing the long-term use of any temporary or bootstrap credential.
  • Apply password policy controls (complexity, length, reuse limits, and lockout/ throttling) to reduce the impact of any leaked or guessed secrets.
  • Isolate sensitive operations so student accounts adhere to least privilege, reducing the blast radius of any single account compromise.
  • Treat onboarding and bulk import pipelines as security-sensitive flows, subject to the same authentication and policy requirements as interactive registration.

How teams detect issues like this

Organizations can detect and monitor for this vulnerability through a mix of review and runtime checks:

  • Code and configuration review: Examine account creation logic for hard-coded password strings, shared secrets, or fixed initialization values in source code, templates, or scripts.
  • Static analysis: Use rules that flag string literals used in authentication flows, calls to user creation functions with constant password parameters, or configuration keys that suggest default credentials.
  • Security testing: Perform credential re-use tests (e.g., checking whether multiple sample student accounts accept the same password) as part of regular application penetration testing.
  • Operational monitoring: Analyze authentication logs for patterns where many distinct accounts log in using the same password or from the same source, which can indicate exploitation.

Sources

SourceLink
github.comgithub.com/Praskla-Technology/assessment-placipy/security/advisories/GHSA-6537-cf56-j9w2

Frequently asked

questions

Once the default password is known, any account that was created with that static password can be accessed; this often means the entire student population provisioned under that scheme.

Typically no. The attacker only needs network access to the PlaciPy login page and knowledge of the default password plus any valid student identifiers, which may be predictable or obtainable from public or institutional sources.

Remove all hard-coded passwords from account creation flows, introduce unique per-user credentials (or secure invitation links), and require users to set their own passwords under enforced policy, ideally with a change on first use for any temporary credentials.

Treat default credentials as a prohibited pattern, enforce design reviews for authentication workflows, apply automated checks for hard-coded secrets, and adopt secure onboarding processes that never rely on shared passwords across users.

Find out what's already
exploitable in your codebase.