/

CVE-2026-14778

Severity:

HIGH RISK

(7.3)

Improper Authorization (CWE-285) in LMS Enrollment API

CVE-2026-14778

Deferred

Vulnerability type

Category:

Improper Authorization

CWE:

CWE-266, CWE-285

Impact:

Unauthorized Access and Enrollment 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

An improper authorization flaw in the Enrollment Management endpoint of the Online Examination & Learning Management System allows remote manipulation of enrollment-related actions using crafted request parameters.

When attacker-controlled values are sent in student_id, schedule_id, or action to /ajax_enroll.php without sufficient permission checks, unauthorized users may be able to view or change enrollment state for other accounts.

Affected context

The vulnerability occurs in the web-based Enrollment Management component exposed via /ajax_enroll.php in the Online Examination & Learning Management System.

It is relevant in deployments where:

  • The enrollment endpoint is reachable over the network (e.g., public-facing or intranet access).
  • Authorization checks rely primarily on user-supplied identifiers such as student_id and schedule_id.
  • Server-side logic does not consistently verify that the caller has rights over the targeted enrollment record.

Exploit preconditions

  • Attack surface: HTTP requests to /ajax_enroll.php in the Enrollment Management module.
  • Required access: Network access to the application; in many cases, a low-privileged or even unauthenticated session if the endpoint is insufficiently protected.
  • Trigger point: Submission of crafted student_id, schedule_id, and action parameters that target another user's enrollment or a schedule the attacker should not control.
  • Why exploitation is possible: The server performs the requested enrollment operations based on client-supplied identifiers without robust, context-aware authorization checks tying the resource to the authenticated user or role.

Why this happens

The core issue is a lack of strict authorization enforcement on sensitive operations within the Enrollment Management logic.

Instead of deriving the target student and schedule from the authenticated session and validating permissions against access-control rules, the code trusts incoming parameters (student_id, schedule_id, action) and executes the requested operation.

This aligns with CWE-285: Improper Authorization and CWE-266: Incorrect Privilege Assignment, where access-control decisions are either missing or incorrectly implemented, allowing users to perform actions beyond their intended privileges.

Potential impact

  • Unauthorized modification of other students' enrollments or exam registrations.
  • Unapproved enrollment into or withdrawal from courses, exams, or learning schedules.
  • Exposure of enrollment-related information for students the attacker should not be able to access.
  • Disruption of examination scheduling and course management workflows.
  • Potential stepping stone for further privilege abuse or data integrity issues in the platform.

General mitigation guidance

Effective mitigation focuses on enforcing strict, server-side authorization checks for every enrollment-related operation.

Common defensive patterns include:

  • Deriving the effective student identity from the authenticated session rather than from client-supplied student_id values.
  • Validating that the current user has explicit permissions (role- or ownership-based) for the targeted schedule_id before executing any action.
  • Centralizing access-control logic so that all sensitive endpoints use consistent checks and do not rely on client-provided identifiers alone.
  • Applying least-privilege design, ensuring that enrollment operations are limited to appropriate roles (e.g., students for self-enrollment, instructors or admins for managed changes).
  • Treating all input parameters as untrusted and using them only after passing them through authorization filters tied to the session context.

How teams detect issues like this

Organizations can detect similar authorization weaknesses through:

  • Code review focused on endpoints handling enrollment, schedule, or user identifiers, checking that authorization is based on session identity and role rather than request parameters alone.
  • Static analysis rules that flag patterns where sensitive operations (create, update, delete) use IDs from request data without preceding permission checks.
  • Application-level security tests and penetration testing that attempt to perform cross-account actions by modifying student_id or schedule_id values.
  • Logging and monitoring of enrollment actions, alerting on anomalous patterns such as a single account modifying many unrelated student records.

Sources

SourceLink
github.comgithub.com/nuiifornet/A033/blob/main/OE-LMS-IDOR-ajax_enroll.md
vuldb.comvuldb.com/cve/CVE-2026-14778
vuldb.comvuldb.com/submit/850695
vuldb.comvuldb.com/vuln/376368
vuldb.comvuldb.com/vuln/376368/cti
sourcecodester.comsourcecodester.com/

Frequently asked

questions

Yes, if the Online Examination & Learning Management System is exposed over the network and /ajax_enroll.php is reachable, an attacker can send crafted HTTP requests to attempt unauthorized enrollment operations.

It depends on how the deployment guards the endpoint. In some configurations, a low-privileged account may be sufficient; in others, weak or missing authentication on the enrollment API could allow unauthenticated abuse.

Tie all enrollment operations to the authenticated user's identity and role, and enforce centralized authorization checks that confirm the user is allowed to act on the given student_id and schedule_id before performing any action.

Establish a consistent access-control framework, avoid trusting client-supplied identifiers for authorization decisions, require code reviews for any new sensitive endpoint, and complement these with security testing that specifically attempts cross-user actions using manipulated IDs.

Find out what's already
exploitable in your codebase.