/

CVE-2026-14753

Severity:

HIGH RISK

(7.3)

Authorization Bypass (CWE-285) in Stumasy Note Handler

CVE-2026-14753

Deferred

Vulnerability type

Category:

Authorization Bypass

CWE:

CWE-285, CWE-639

Impact:

Unauthorized Access to Assignment Notes and Data

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

An authorization bypass vulnerability in the Stumasy Note/Assignment Handler allows attackers to manipulate the assignment_item_id parameter to access or modify notes without proper permission checks.

When external clients can call the affected PHP endpoint remotely, this flaw may expose or alter assignment-related data across user boundaries.

Affected context

The vulnerability occurs in the Stumasy application within the /PHP/objects/notes Note Handler/Assignment Handler component.

It is relevant in deployments where assignment-related notes are exposed via HTTP parameters, and where the assignment_item_id value is used to identify records without consistently enforcing ownership or role-based checks.

Any environment that allows remote access to these endpoints and relies on parameter-based resource selection without robust authorization controls may be affected.

Exploit preconditions

  • Attack surface: Remote HTTP interface to the Note Handler/Assignment Handler (/PHP/objects/notes).
  • Required access: Ability to send crafted requests to the application (e.g., authenticated user with access to notes, or potentially unauthenticated if the endpoint is exposed).
  • Trigger point: Manipulation of the assignment_item_id argument in requests that read or modify notes or assignment entries.
  • Why exploitation is possible: The server logic appears to trust the provided assignment_item_id without sufficiently verifying that the requesting user is authorized to access the referenced resource, leading to an authorization bypass consistent with CWE-285 and CWE-639.

Why this happens

The underlying issue stems from insufficient authorization checks on resource identifiers passed via request parameters.

The application uses assignment_item_id to select which note or assignment record to operate on but does not consistently validate that the caller owns or is permitted to access that specific item.

This pattern aligns with CWE-285: Improper Authorization and CWE-639: Insecure Direct Object Reference (IDOR), where direct references to internal objects are exposed and trusted without enforcing access control rules on every request.

Potential impact

  • Attackers may read notes or assignment data belonging to other users.
  • Attackers could modify or delete notes associated with assignments they do not own.
  • Grading or feedback information tied to assignments may be altered or tampered with.
  • Sensitive educational or personal information stored in notes can be exposed.
  • Integrity of assignment workflows and audit trails may be undermined.

General mitigation guidance

Effective mitigation typically focuses on enforcing strict authorization checks around resource identifiers and reducing trust in client-supplied IDs.

Common defensive patterns include:

  • Implementing centralized access control logic that verifies user permissions for every assignment_item_id reference, regardless of client role or endpoint.
  • Using server-side lookup based on the authenticated user's context instead of trusting arbitrary IDs from the request.
  • Applying least-privilege principles so that users can only access notes and assignments explicitly associated with their account or role.
  • Introducing consistent authorization middleware that wraps all note and assignment operations, ensuring that checks cannot be bypassed by calling different internal functions.
  • Limiting disclosure of internal identifiers where possible and validating relationships between user accounts and target resources before performing any read or write actions.

How teams detect issues like this

Organizations can detect similar authorization issues through:

  • Code review focused on endpoints that accept resource IDs (like assignment_item_id), checking for missing or inconsistent authorization checks before database queries.
  • Static analysis rules that flag direct use of request parameters in data-access operations without preceding permission validation.
  • Logging and monitoring of access patterns, looking for unusual cross-user access to notes or assignments (e.g., one account repeatedly accessing many different IDs).
  • Security testing and automated integration tests that attempt ID tampering (IDOR tests) across note and assignment-related APIs.
  • Policy-based enforcement where any controller or handler interacting with user-scoped resources must call standardized authorization routines.

Sources

SourceLink
github.comgithub.com/mjperpinosa/stumasy/
github.comgithub.com/mjperpinosa/stumasy/issues/9
vuldb.comvuldb.com/cve/CVE-2026-14753
vuldb.comvuldb.com/submit/849496
vuldb.comvuldb.com/vuln/376342
vuldb.comvuldb.com/vuln/376342/cti

Frequently asked

questions

Exploitability depends on how exposed the Note/Assignment Handler endpoints are. If accessible to general users, any account that can reach them may attempt ID tampering with assignment_item_id to access other users' notes.

In many deployments, note and assignment features require authentication, so attackers would typically need a valid account. However, if the application exposes these endpoints without authentication, then unauthorized remote users could also attempt exploitation.

The safest approach is to ensure that every request involving assignment_item_id performs a strict authorization check to confirm that the authenticated user is permitted to access the specified note or assignment. Centralizing this logic and reusing it across all related handlers reduces the chance of gaps.

Adopt a standard access control framework, require explicit permission checks for any resource referenced by client-supplied IDs, and include automated tests and code review checklists focused on broken access control and IDOR scenarios. Consistent use of middleware or policy enforcement layers helps prevent future oversights.

Find out what's already
exploitable in your codebase.