/

CVE-2026-10236

Severity:

HIGH RISK

(7.3)

Improper Authorization in Water Billing Management System

CVE-2026-10236

Deferred

Vulnerability type

Category:

Improper Authorization

CWE:

CWE-266, CWE-285

Impact:

Privilege Escalation and Unauthorized Account Manipulation

Severity:

HIGH RISK

(7.3)

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

The Water Billing Management System 1.0 exposes an authorization flaw in the /classes/Users.php?f=save user management endpoint that allows certain operations to be performed without proper permission checks.

A remote attacker who can reach this endpoint may be able to create or modify user accounts or related attributes beyond their intended privileges.

Affected context

This vulnerability appears in the user management logic of SourceCodester Water Billing Management System 1.0, specifically in the /classes/Users.php?f=save endpoint.

It is relevant in deployments where the application is network-accessible and where role or permission checks around user creation or modification are incomplete, misapplied, or missing.

The issue typically manifests when the application trusts client-supplied data about user identities or roles without consistently verifying the caller's actual authorization context on the server.

Exploit preconditions

  • Attack surface: HTTP(S) interface of the Water Billing Management System, targeting /classes/Users.php?f=save.
  • Required access: Network-level access to the application; in many configurations, no valid high-privilege account is required if the endpoint is insufficiently protected.
  • Trigger point: Submission of crafted HTTP requests (e.g., form submissions or API-like calls) that invoke user creation or modification logic.
  • Why exploitation is possible: The server-side code does not enforce robust authorization checks (or enforces them inconsistently), allowing callers to perform actions reserved for higher-privilege roles by manipulating request parameters or calling the endpoint directly.

Why this happens

The root cause aligns with CWE-285: Improper Authorization and CWE-266: Incorrect Privilege Assignment.

The application's user management endpoint appears to rely on weak or missing server-side authorization controls when handling user save operations.

Insecure patterns may include:

  • Assuming that access to the endpoint implies appropriate privileges.
  • Trusting client-controlled fields to determine which user record is being modified or what role/privilege is assigned.
  • Not consistently re-checking the authenticated user's role or permission set before applying sensitive changes.

This leads to a situation where an attacker can trigger high-privilege operations (e.g., creating admin-like accounts, changing other users' data) without holding the necessary authorization.

Potential impact

  • Creation of new user accounts with elevated roles or permissions.
  • Unauthorized modification of existing user accounts, including credential or role changes.
  • Escalation from a low-privileged or unauthenticated position to administrative control of the billing system.
  • Tampering with customer billing records indirectly through compromised or newly created privileged accounts.
  • Loss of integrity and confidentiality of user and billing data managed by the application.

General mitigation guidance

Effective mitigation focuses on consistently enforcing server-side authorization and tightening privilege boundaries:

  • Apply role- and permission-based checks on the server for every operation within /classes/Users.php?f=save, ensuring only appropriate roles can create, update, or assign permissions to users.
  • Implement least privilege by defining granular capabilities (e.g., "create user", "edit own profile", "edit other users", "assign admin role") and mapping them minimally to roles.
  • Avoid relying on client-controlled fields to drive authorization decisions; derive the acting user's identity and permissions exclusively from the server-side session or token.
  • Introduce centralized authorization helpers or middleware so all user-management operations use a common, auditable decision point rather than ad hoc checks scattered throughout the code.
  • Log sensitive user-management actions (account creation, role changes, password resets) to support monitoring and incident response, while maintaining privacy best practices.

How teams detect issues like this

Organizations can surface this type of flaw using a mix of review and testing techniques:

  • Static analysis and code review:
  • Look for user-management endpoints that modify accounts or roles without explicit authorization checks.
  • Flag patterns where user IDs, roles, or privilege levels are taken directly from request parameters and written to the database.
  • Review for duplicated or inconsistent authorization logic instead of centralized, reusable checks.
  • Dynamic testing:
  • Attempt to perform privileged operations (e.g., creating admin users, editing other accounts) while authenticated as a low-privileged user or not authenticated, and observe server responses.
  • Use automated web security scanners configured to probe parameter tampering and privilege escalation paths on user endpoints.
  • Policy enforcement:
  • Adopt secure coding guidelines that mandate explicit authorization checks on all state-changing user-management operations.
  • Integrate security testing into CI/CD pipelines so new or modified endpoints are automatically evaluated.

Sources

SourceLink
github.comgithub.com/renzortega1337/Security-Research-/blob/main/Unauthenticated%20Admin%20Creation%20in%20PHP%20System.md
vuldb.comvuldb.com/cve/CVE-2026-10236
vuldb.comvuldb.com/submit/823134
vuldb.comvuldb.com/vuln/367515
vuldb.comvuldb.com/vuln/367515/cti
sourcecodester.comsourcecodester.com/

Frequently asked

questions

Exploitability depends on how the application is deployed and which network paths are exposed, but because it affects a remotely accessible endpoint, it can often be exploited over the network if the system is reachable and the flawed authorization logic is present.

Not necessarily. In some deployments, weak or missing checks may allow unauthenticated attackers to call the endpoint directly. In others, a low-privileged account may be sufficient to escalate to higher privileges by abusing the user save functionality.

Enforce strict, centralized authorization checks for all operations in the user management endpoint, ensuring that only users with explicit permissions can create, modify, or assign roles and privileges, and that the acting user's identity comes from trusted server-side context.

Adopt a consistent access control model (e.g., role- or attribute-based), require authorization checks for every sensitive action, encapsulate these checks in reusable helpers or middleware, and validate through regular security testing and code review that no privileged operations bypass the central authorization logic.

Find out what's already
exploitable in your codebase.