/

CVE-2026-24665

Severity:

HIGH RISK

(8.7)

XSS in Open eClass Assignment Submissions

CVE-2026-24665

Analyzed

Vulnerability type

Category:

Cross-Site Scripting (XSS)

CWE:

CWE-79

Impact:

Stored Cross-Site Scripting leading to instructor session compromise and privilege abuse

Severity:

HIGH RISK

(8.7)

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

Open eClass prior to version 4.2 contains a stored Cross-Site Scripting (XSS) vulnerability that allows authenticated students to embed malicious JavaScript within uploaded assignment files or associated content.

When an instructor later views the submission in the web interface, the injected script executes in the instructor's browser, potentially enabling account compromise or other unauthorized actions within the platform.

Affected context

The vulnerability occurs in the assignment submission and review workflow of the Open eClass course management system.

It manifests when student-controlled content in uploaded assignment files or metadata is rendered in an instructor's browser without proper HTML/JavaScript sanitization or output encoding.

The issue primarily impacts environments where students can submit assignments through the web interface and instructors review those submissions through the platform's UI.

Exploit preconditions

  • Attack surface: Web-based assignment submission and viewing interfaces within Open eClass.
  • Required access: Authenticated student account capable of submitting assignments to a course.
  • Trigger point: An instructor (or other privileged user) opens or previews the malicious submission via the platform's UI.
  • Why exploitation is possible: User-controlled content is stored on the server and subsequently rendered in a privileged user's browser without sufficient output encoding or sanitization, allowing embedded scripts to execute in the instructor's session context.

Why this happens

This vulnerability maps to CWE-79: Improper Neutralization of Input During Web Page Generation (Cross-Site Scripting).

The root cause is that the application stores user-controlled content (from student submissions) and later injects it into HTML responses for instructor views without robust contextual output encoding.

As a result, any HTML/JavaScript fragments included by a student can break out of expected content boundaries and execute as active script in the instructor's browser.

The flaw lies in treating stored submission content as display-ready HTML instead of untrusted data that must be encoded or sanitized for each rendering context (such as inner HTML, attributes, or script-adjacent contexts).

Potential impact

  • Compromise of instructor sessions via theft of session cookies or tokens (where not otherwise protected).
  • Execution of arbitrary JavaScript in the instructor's browser, allowing actions to be performed on their behalf (e.g., grading manipulation, content changes).
  • Unauthorized access to sensitive course information, student records, or private messages visible to the instructor.
  • Use of the instructor account as a pivot to target other users or escalate privileges within the platform.
  • Injection of additional phishing content or malicious links into the course environment.

General mitigation guidance

Mitigation focuses on treating all student-supplied submission content as untrusted and constraining how it is rendered in instructor-facing views.

Recommended defensive patterns include:

  • Applying strict, context-aware output encoding whenever user-generated content is inserted into HTML pages, ensuring that characters relevant to HTML and JavaScript are neutralized.
  • Using a vetted HTML sanitization library when rich-text content is needed, configured with a minimal, allowlist-based set of tags and attributes.
  • Avoiding direct rendering of file contents or metadata as raw HTML; instead render as plain text or via safe viewers that do not interpret embedded scripts.
  • Segregating untrusted content into sandboxed frames or separate domains when possible (e.g., using iframes with restrictive attributes or content security boundaries).
  • Enforcing a restrictive Content Security Policy (CSP) to reduce the impact of any residual XSS paths, such as disallowing inline scripts and restricting script sources.

How teams detect issues like this

To detect and monitor for this class of vulnerability, organizations can:

  • Use static application security testing (SAST) tools to flag unencoded output of user-controlled data into HTML templates, particularly in instructor-facing views and assignment-related controllers.
  • Establish code review checklists that explicitly require verification of output encoding or sanitization for all data paths originating from student submissions and profiles.
  • Employ dynamic application security testing (DAST) or interactive testing tools to probe assignment submission workflows with typical XSS payloads and observe rendering behavior.
  • Introduce centralized helper functions for output encoding and mandate their use via coding standards and linting rules, making deviations easier to detect.
  • Monitor application logs and web server logs for anomalous patterns, such as suspicious script tags or event handlers embedded in stored content fields.

Sources

SourceLink
github.comgithub.com/gunet/openeclass/security/advisories/GHSA-2qgm-m7fm-m888

Frequently asked

questions

Yes, if the Open eClass instance is reachable over the internet and student accounts can be created or accessed remotely, an attacker can exploit the issue simply by submitting crafted assignments and waiting for an instructor to view them.

No elevated privileges are required beyond a standard student role with permission to submit assignments. The attack targets instructors or other higher-privileged users who review those submissions.

The most robust fix pattern is to treat all student-supplied data as untrusted and apply context-aware output encoding or sanitization before rendering it in instructor views, ideally through centralized template helpers or sanitization APIs rather than ad hoc filtering.

Preventing similar issues involves adopting a secure output encoding strategy across the application, using frameworks that auto-escape by default, integrating XSS-focused checks into code review and CI pipelines, and complementing these controls with a restrictive Content Security Policy to limit the impact of any remaining injection paths.

Find out what's already
exploitable in your codebase.