/

CVE-2020-37186

Severity:

CRITICAL RISK

(9.8)

Code Injection in Chevereto Core

CVE-2020-37186

Awaiting Analysis

Vulnerability type

Category:

Code Injection

CWE:

CWE-94

Impact:

Remote Code Execution (RCE) on the web server

Severity:

CRITICAL RISK

(9.8)

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

Chevereto 3.13.4 Core contains a code injection vulnerability in the installation database configuration flow, where the database table prefix parameter can be abused to write executable PHP code to disk.

An attacker who can reach the installer endpoint and submit crafted POST data may inject a PHP shell file and execute arbitrary system commands on the hosting server.

Affected context

The vulnerability exists in Chevereto 3.13.4 Core during the application setup and database configuration phase.

It affects deployments where:

  • The installation or setup script is exposed over the network (e.g., fresh installs or improperly removed installer files), and
  • User-supplied configuration values (such as the database table prefix) are accepted and processed into PHP or filesystem content without strict sanitization.

In such contexts, an attacker can reach the installer and influence how configuration data is written to the application's code or configuration files.

Exploit preconditions

  • Attack surface: HTTP(S) interface of the Chevereto installer / setup endpoint.
  • Required access: Network access to the installation page; no prior authentication if the installer is still accessible.
  • Trigger point: Submission of a crafted POST request during database configuration, specifically manipulating the database table prefix parameter.
  • Why exploitation is possible: The installer logic incorporates untrusted input into PHP-related output or configuration without proper neutralization, enabling injection of arbitrary PHP code that is later interpreted by the PHP engine.

Why this happens

This issue stems from CWE-94: Improper Control of Generation of Code ('Code Injection').

During installation, the database table prefix parameter—intended to be a simple string used for naming database tables—is treated as a trusted value and propagated into PHP-relevant contexts such as configuration or generated files.

Because this value is not rigorously validated (e.g., restricted to safe characters or separated from any PHP syntax), an attacker can supply a value containing PHP code constructs.

When the installer writes this data to a file that is subsequently executed by the PHP runtime, the injected code is interpreted, leading to arbitrary command execution on the underlying system.

Potential impact

  • Remote execution of arbitrary PHP code on the server.
  • Execution of arbitrary operating system commands under the web server's privileges.
  • Installation of persistent web shells and backdoors.
  • Full compromise of the Chevereto application and its data.
  • Lateral movement within the hosting environment or network, depending on server configuration.
  • Use of the compromised server for further attacks, spam, or malware distribution.

General mitigation guidance

Effective mitigation focuses on treating all installation and configuration inputs as untrusted and ensuring they cannot influence executable code:

  • Restrict configuration fields such as database table prefixes to a strict character whitelist (e.g., alphanumeric and underscore) and enforce length limits.
  • Avoid dynamically generating PHP or other executable files directly from raw user input; if generation is required, separate data from executable logic and avoid interpolating input into code.
  • Use parameterized patterns when constructing identifiers such as table names, concatenating only validated fragments that cannot break context.
  • Ensure installer and setup scripts are disabled or removed after initial installation to reduce long-term exposure.
  • Run the application and web server with least-privilege accounts and restrict filesystem write permissions so the web layer cannot create or modify executable code locations.
  • Implement a secure deployment checklist that includes verifying installer accessibility and tightening file permissions before going live.

How teams detect issues like this

Detection can combine code-level review with runtime monitoring:

  • Static analysis: Define rules to detect concatenation of user-supplied input into PHP code, configuration templates, or file-writing operations that land in web-accessible locations.
  • Code review: Flag any installer or configuration routines that:
  • Write files under the web root or any directory executed by PHP,
  • Accept free-form text for parameters that should be simple identifiers (like table prefixes),
  • Mix configuration data and executable logic within the same file.
  • Configuration and policy checks: Enforce policies that prevent the web process from writing to directories that the interpreter executes (e.g., web root) and flag deployments where installer endpoints remain reachable.
  • Runtime monitoring: Use web server logs, WAF rules, and file integrity monitoring to detect suspicious POST requests to installer paths and unexpected creation of new .php files.
  • Automated tooling: Integrate SAST and configuration scanning tools into CI/CD pipelines to highlight insecure code generation and unsafe installation workflows before release.

Sources

SourceLink
chevereto.comchevereto.com/
github.comgithub.com/Chevereto/Chevereto-Free/releases
exploit-db.comexploit-db.com/exploits/47903
vulncheck.comvulncheck.com/advisories/chevereto-core-remote-code-execution

Frequently asked

questions

Yes. If the Chevereto installer or configuration endpoint is exposed over the network, an attacker can send crafted POST requests to exploit the vulnerability remotely.

Typically no, provided the installation or configuration interface is publicly reachable and does not enforce authentication. However, if access to the installer is restricted by additional controls (e.g., HTTP auth, IP allowlists), those controls would raise the bar for exploitation.

The safest pattern is to strictly validate and sanitize all configuration parameters, particularly those used in identifiers or file generation, and to avoid generating executable code from user-controlled data. In addition, ensure that installer scripts are not accessible in production environments and that the web server process cannot write executable files in web-accessible paths.

Adopt secure coding practices for installation and configuration components: treat all setup inputs as untrusted, enforce strong validation and whitelisting, separate code from configuration, and regularly review deployment artifacts to ensure installers are disabled post-setup. Complement this with automated security testing and least-privilege filesystem and process configurations.

Find out what's already
exploitable in your codebase.