/

CVE-2026-28495

Severity:

CRITICAL RISK

(9.6)

CSRF in GetSimple CMS massiveAdmin Plugin

CVE-2026-28495

Analyzed

Vulnerability type

Category:

Cross-Site Request Forgery (CSRF)

CWE:

CWE-352

Impact:

Remote Code Execution via CSRF-Driven Configuration File Overwrite

Severity:

CRITICAL RISK

(9.6)

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 massiveAdmin plugin for GetSimple CMS-CE allows the gsconfig.php configuration file to be overwritten with arbitrary PHP code through its configuration editor module.

Because this form lacks CSRF protection, a remote attacker can trick a logged-in administrator into submitting a malicious request, resulting in remote code execution on the web server.

Affected context

This vulnerability arises in GetSimple CMS-CE installations that include the massiveAdmin plugin (v6.0.3) with its gsconfig editor module enabled.

It becomes relevant when administrators manage site configuration through the web interface, and their browsers can be induced to load untrusted content (e.g., attacker-controlled web pages, emails, or embedded content) while they are authenticated to the CMS.

In this context, the absence of request origin validation or CSRF tokens on the gsconfig editor endpoint means that configuration changes can be triggered by external sites without direct administrator intent.

Exploit preconditions

  • Attack surface: HTTP(S) endpoint for the massiveAdmin gsconfig editor within the GetSimple CMS admin interface.
  • Required attacker access: No direct authentication to the CMS is needed; the attacker must only be able to deliver a crafted web page, email, or embedded content to an administrator.
  • Victim state requirements: An administrator must be logged into the GetSimple CMS in the same browser session and visit or interact with the attacker-controlled content.
  • Trigger point: Submission of the gsconfig editor form with attacker-supplied content, initiated indirectly via the victim's browser (e.g., auto-submitting HTML form, JavaScript-triggered request where possible).
  • Why exploitation is possible: The gsconfig editor endpoint accepts state-changing POST requests without validating a CSRF token, Referer/Origin headers, or other anti-CSRF controls, allowing an attacker to cause the admin's browser to send a valid configuration update containing arbitrary PHP code.

Why this happens

The root cause is the lack of CSRF defenses on a high-privilege, state-changing operation that edits a critical configuration file.

The massiveAdmin gsconfig editor trusts any properly formed request from a browser with a valid admin session cookie, without ensuring that the request was intentionally initiated from the legitimate CMS UI.

This corresponds to CWE-352: Cross-Site Request Forgery (CSRF), where a web application fails to distinguish between a genuine user action and a forged request from another origin.

Because the endpoint directly writes user-supplied content into gsconfig.php, which is interpreted as PHP by the server, the CSRF flaw combines with configuration file editing to yield remote code execution.

Potential impact

  • Execution of arbitrary PHP code on the web server in the context of the web application.
  • Full compromise of the CMS instance, including creation or modification of administrative accounts.
  • Exposure or modification of content, configuration, and stored data managed by the CMS.
  • Use of the compromised server as a pivot point for further attacks within the hosting environment.
  • Deployment of web shells or backdoors for persistent access.

General mitigation guidance

Effective mitigation centers on enforcing strong anti-CSRF protections and reducing the power of configuration-editing features:

  • Introduce robust CSRF tokens on all state-changing admin endpoints, especially configuration editors, and validate them server-side for every request.
  • Validate the Origin and/or Referer headers for admin operations to confirm requests originate from the legitimate CMS domain.
  • Restrict or disable browser-based editing of executable configuration files such as gsconfig.php, preferring file-based configuration managed through deployment workflows.
  • Apply least-privilege principles to administrative features, limiting access to highly sensitive operations to trusted roles and possibly requiring re-authentication for dangerous actions.
  • Separate executable code and configuration, ensuring that configuration data is treated as passive data wherever possible rather than as inline PHP.

How teams detect issues like this

Detection can combine application-layer review with security tooling:

  • Use static application security testing (SAST) to identify admin routes that accept POST/PUT/DELETE requests without CSRF token verification or origin checks.
  • During code review, flag any configuration or file-editing features that:
  • Accept raw content and write it directly to PHP or other executable files.
  • Lack explicit CSRF handling, such as token generation and server-side verification.
  • Configure web application firewalls (WAFs) or reverse proxies with rules to enforce or monitor Origin/Referer consistency for admin paths.
  • Monitor server logs for unusual configuration edits, especially sudden changes to gsconfig.php or the introduction of suspicious PHP constructs.
  • Incorporate automated security checks in CI/CD pipelines that scan for missing CSRF defenses on admin forms and sensitive endpoints.

Sources

SourceLink
github.comgithub.com/GetSimpleCMS-CE/GetSimpleCMS-CE/security/advisories/GHSA-92wv-q2jp-qg88

Frequently asked

questions

Yes. An attacker does not need their own CMS account; they can exploit the issue by inducing a logged-in administrator to load attacker-controlled content that silently submits a forged request.

Successful exploitation leads to execution of arbitrary PHP code on the server with the privileges of the web server process, effectively granting the attacker full control over the CMS and potentially broader system access.

Implement strong anti-CSRF protections on all privileged, state-changing endpoints and avoid exposing direct file or configuration editors for executable files through the web interface.

Adopt a secure-by-default design for admin features: require CSRF tokens and origin validation, reduce or eliminate web-based editing of executable files, and enforce security reviews for any feature that writes to configuration or code-related files.

Find out what's already
exploitable in your codebase.