/

CVE-2026-32930

Severity:

HIGH RISK

(7.1)

Insecure Direct Object Reference (IDOR) in Chamilo LMS

CVE-2026-32930

Analyzed

Vulnerability type

Category:

Insecure Direct Object Reference (IDOR)

CWE:

CWE-639

Impact:

Unauthorized Access and Manipulation of Gradebook Evaluations

Severity:

HIGH RISK

(7.1)

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 Insecure Direct Object Reference (IDOR) issue in Chamilo LMS allows any authenticated teacher to access and modify gradebook evaluation records across courses by tampering with a GET parameter.

By changing the editeval parameter on the gradebook evaluation edit page, a teacher can view and update evaluation settings (name, max score, weight) belonging to other courses they should not control.

Affected context

This vulnerability occurs in Chamilo LMS instances where:

  • The gradebook evaluation edit page is accessible to authenticated teachers.
  • Evaluation records are referenced directly by identifiers passed via the editeval GET parameter.
  • Server-side authorization does not recheck that the requesting teacher is associated with the course owning the evaluation.

In such setups, course-level isolation of gradebook management is enforced only by client-side navigation and assumptions, not by robust server-side access controls.

Exploit preconditions

  • Attack surface: Web interface of the Chamilo LMS gradebook evaluation edit page.
  • Required access: Authenticated teacher-level account on the platform.
  • Trigger point: HTTP requests to the evaluation edit endpoint where editeval identifies the evaluation to edit.
  • Why exploitation is possible: The application trusts the evaluation identifier supplied in the editeval GET parameter and does not verify that the logged-in teacher is authorized for the course that owns that evaluation, enabling horizontal privilege abuse across courses.

Why this happens

The root cause aligns with CWE-639: Authorization Bypass Through User-Controlled Key.

The application exposes internal evaluation identifiers in the editeval GET parameter and uses them directly to look up gradebook evaluations without enforcing a proper server-side ownership or course-membership check.

This pattern treats the presence of a valid session as sufficient authorization and relies on the client not altering the identifier, instead of enforcing a robust access control decision on every request.

Potential impact

  • A teacher may view gradebook evaluation configurations for courses they do not own or manage.
  • A teacher may modify evaluation settings (name, maximum score, weight) for other courses, potentially disrupting grading schemes.
  • Grade calculations and student results in affected courses can be skewed or invalidated due to tampered evaluation weights or scores.
  • Integrity and trust in course grading and institutional records can be undermined, leading to disputes and potential compliance issues.

General mitigation guidance

Effective mitigation focuses on strengthening server-side authorization around object access:

  • Enforce course-level ownership or role checks on every access to gradebook evaluations, ensuring the requester is a teacher or administrator for the course that owns the evaluation.
  • Implement centralized access-control routines (e.g., policy or permission checks) that validate both the authenticated user and the target resource context before performing read or write operations.
  • Avoid relying solely on obscured identifiers or UI-level restrictions; treat all client-supplied identifiers (such as editeval) as untrusted and subject them to strict authorization checks.
  • Use a consistent authorization model across the application, defining clear rules for which roles can manipulate which course resources, and ensure that gradebook operations always consult this model.
  • Apply least-privilege principles so that teacher accounts can manipulate only evaluations belonging to their own courses, with cross-course access reserved for narrowly scoped administrative roles where necessary.

How teams detect issues like this

Detection typically combines code-level and behavior-level approaches:

  • Static analysis and code review: Look for controller actions or handlers that load evaluations or gradebook entities by ID from request parameters (e.g., $_GET['editeval'], route parameters) without an immediate, explicit check tying the resource to the current user's course or permissions.
  • Access-control review: Map endpoints that manipulate gradebook evaluations and verify that they consistently call centralized authorization functions or policies; flag any direct database lookups followed by updates that lack these checks.
  • Logging and anomaly detection: Instrument audit logs to capture which users edit which evaluation IDs and from which courses; alerts can be generated when a teacher edits evaluations outside their assigned course set.
  • Automated testing: Use security-focused integration tests that attempt to access or modify evaluations across course boundaries using different teacher accounts, validating that unauthorized operations are denied with appropriate error responses.

Sources

SourceLink
github.comgithub.com/chamilo/chamilo-lms/commit/63e1e6d3d717bd537c7c61719416da35aaa658dd
github.comgithub.com/chamilo/chamilo-lms/commit/f03f681df939db0429edc8414fb3ce4e4b80d79d
github.comgithub.com/chamilo/chamilo-lms/security/advisories/GHSA-9h22-wrg7-82q6

Frequently asked

questions

Yes, but only by authenticated users. An attacker must log in as a teacher and then manipulate the editeval parameter in requests to target evaluations from other courses.

The attacker needs a valid teacher-level account or any role that can access the gradebook evaluation edit page. No administrative privileges are required, and cross-course access is achieved by guessing or enumerating evaluation identifiers.

Implement strict server-side access control that verifies ownership or authorization for every resource access. For gradebook evaluations, the application should confirm that the authenticated user is permitted to manage the course associated with the evaluation ID before allowing read or write operations.

Adopt a standardized access-control layer, require explicit authorization checks in all handlers that use user-supplied identifiers, and include automated tests and code-review checklists focused on IDOR and broken access control. Treat all client-controlled identifiers as untrusted and validate both the identity and the context (course, organization, or tenant) before performing any sensitive action.

Find out what's already
exploitable in your codebase.