/

CVE-2025-70073

Severity:

HIGH RISK

(7.2)

Code Injection in ChestnutCMS Template Creation Function

CVE-2025-70073

Analyzed

Vulnerability type

Category:

Code Injection

CWE:

CWE-94

Impact:

Remote Code Execution

Severity:

HIGH RISK

(7.2)

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

ChestnutCMS versions 1.5.8 and earlier contain a code injection flaw in the template creation functionality that can allow attacker-controlled input to be executed as server-side code.

Under typical deployments where templates are processed dynamically, a remote attacker can abuse this feature to run arbitrary code on the server hosting ChestnutCMS.

Affected context

This vulnerability affects ChestnutCMS instances that expose the template creation feature to users over a network, such as through an administrative or content-editing interface.

It is most relevant when user-supplied template data is interpreted or compiled into executable code (e.g., server-side template languages or scriptable templates).

The risk is elevated when template creation is accessible to low-privileged or untrusted users, or when authentication around template management is weak or misconfigured.

Exploit preconditions

  • Attack surface: HTTP(S) interface that provides template creation or management in ChestnutCMS.
  • Required access: Ability to submit or modify template content (e.g., through a CMS UI, API endpoint, or similar feature). In some deployments this may require authenticated access; in others, misconfiguration may expose it more broadly.
  • Trigger point: The crafted template is saved and later rendered, compiled, or otherwise processed by the server-side template engine.
  • Why exploitation is possible: The template creation logic incorporates attacker-controlled content into a context where it is treated as executable code or powerful template expressions without adequate validation, sanitization, or sandboxing, consistent with CWE-94 (Improper Control of Generation of Code).

Why this happens

The root cause is improper handling of dynamically generated code during template creation.

ChestnutCMS appears to allow template content to be interpreted by a template engine or scripting environment that can execute logic with the privileges of the web application.

If user input is inserted directly into executable constructs—such as inline scripting blocks, template expressions, or dynamic include statements—without strict validation or restriction, an attacker can craft templates that embed malicious code.

This aligns with CWE-94, where the application fails to constrain how input influences generated code, allowing untrusted data to modify behavior at runtime.

Potential impact

  • Remote execution of arbitrary code on the CMS server
  • Full compromise of the web application and its data stores
  • Reading, modifying, or deleting CMS content and configuration
  • Installing backdoors or web shells for persistent access
  • Using the compromised server as a pivot point for further attacks in the hosting environment

General mitigation guidance

Mitigation should focus on eliminating direct code execution paths from template content and tightening control over template capabilities.

Recommended defensive patterns include:

  • Restricting template engines to a safe, declarative subset that cannot execute arbitrary code or access sensitive runtime APIs.
  • Validating and sanitizing template content, disallowing dangerous constructs such as inline scripting, arbitrary includes, or direct function invocation.
  • Applying strong access control around template creation and modification, limiting these actions to tightly controlled, trusted roles.
  • Running the CMS and template engine with least-privilege OS and database accounts to reduce the blast radius if a template is abused.
  • Separating configuration and code from editable content so that runtime behavior cannot be altered solely through template changes.

How teams detect issues like this

Detection can combine code-centric and operational approaches:

  • Static analysis: Scan the codebase for dynamic evaluation patterns in template handling (e.g., eval-like constructs, dynamic code compilation, or execution APIs influenced by template content).
  • Code review: Examine template processing logic for any point where user-controlled template fields are mapped into executable or privileged template constructs.
  • Template policy enforcement: Implement rules that flag or reject templates containing risky patterns (e.g., scripting tags, dangerous filters, or calls to system-level APIs).
  • Runtime monitoring: Use application and server logs to detect unusual template changes or errors indicative of malicious expressions, and enable alerts for unexpected modifications in template storage.
  • Automated tooling: Employ secure code review or SAST tools configured with rules for code injection and unsafe dynamic code generation to identify unsafe patterns during development and deployment.

Sources

SourceLink
github.comgithub.com/liweiyi/ChestnutCMS/issues/8

Frequently asked

questions

Yes. As described, a remote attacker who can reach the template creation functionality and provide crafted template content may be able to trigger arbitrary code execution on the server.

The attacker must be able to create or modify templates. In many CMS deployments, this requires at least some level of authenticated access, but misconfigurations or overly broad permissions can lower that bar.

The safest pattern is to ensure that template content is never treated as raw executable code. Use a template engine configured in a safe, non-Turing-complete mode, remove support for arbitrary code execution from templates, and strictly validate template syntax against an allowed subset.

Avoid designs that rely on runtime code generation from user input, apply strong input validation and context-aware encoding, and adopt secure defaults in template engines.

Additionally, integrate security reviews, automated scanning, and least-privilege principles into the development and deployment lifecycle for CMS features.

Find out what's already
exploitable in your codebase.