/

CVE-2026-11456

Severity:

HIGH RISK

(7.3)

SQL Injection (CWE-89) via gblOrgID in Chanjet CRM HTTP GET Handler

CVE-2026-11456

Deferred

Vulnerability type

Category:

SQL Injection

CWE:

CWE-74, CWE-89

Impact:

Unauthorized Database Access and Manipulation

Severity:

HIGH RISK

(7.3)

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

Chanjet CRM 1.0 contains a SQL injection vulnerability in the HTTP GET request handler for /tools/jxf_dump_systable.php, where the gblOrgID parameter is incorporated into database queries without proper sanitization.

A remote attacker can manipulate this parameter to alter SQL logic, which may lead to unauthorized data access, modification, or other database-level impacts when the vulnerable endpoint is exposed.

Affected context

The vulnerability occurs in Chanjet CRM 1.0 within the HTTP GET request handling for /tools/jxf_dump_systable.php, specifically when processing the gblOrgID query parameter.

It is relevant in deployments where:

  • The CRM application is exposed over a network (intranet or internet)
  • The /tools/jxf_dump_systable.php endpoint is reachable to untrusted users
  • Database queries are built using values from gblOrgID without robust parameterization or encoding

In such contexts, user-controlled input can influence SQL statements executed by the backend database.

Exploit preconditions

  • Attack surface: Network-accessible web interface of Chanjet CRM 1.0
  • Required access: Ability to send crafted HTTP GET requests to /tools/jxf_dump_systable.php
  • User interaction: None required; the attack is fully server-side once the request is received
  • Trigger point: Server-side processing of the gblOrgID parameter as part of a database query
  • Why exploitation is possible: The application appears to incorporate gblOrgID directly (or with incomplete filtering) into SQL statements rather than using strict parameterized queries or safe encoding, enabling attackers to inject or modify query fragments.

Why this happens

This issue stems from constructing SQL statements with untrusted input from the gblOrgID HTTP GET parameter.

Instead of using parameterized queries or a safe query-building abstraction, the application likely concatenates or interpolates the raw parameter into SQL strings.

This pattern aligns with CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection'), where metacharacters such as quotes, delimiters, or operators are not adequately neutralized before reaching the database.

The presence of CWE-74: Improper Neutralization of Special Elements in Output Used by a Downstream Component reflects that data from one component (the web layer) is passed downstream (the database) without enforcing strict separation between data and control instructions.

Potential impact

  • Attackers may read data they are not authorized to access, depending on database contents and query context.
  • Data in CRM tables could be modified, corrupted, or deleted via injected SQL commands.
  • Authentication or authorization checks may be bypassed if query conditions can be altered.
  • Additional SQL statements (such as administrative commands) may be executed if the database configuration permits stacked queries.
  • The integrity of CRM reporting, exports, or system-table dumps may be compromised.

General mitigation guidance

Effective mitigation focuses on eliminating the ability of user input to change SQL control flow and ensuring the database treats input strictly as data:

  • Use parameterized queries (prepared statements) for all database access paths that incorporate external input, including gblOrgID.
  • Avoid building SQL strings through concatenation, interpolation, or dynamic fragments derived directly from request parameters.
  • Apply strict server-side validation for identifier-like parameters (such as organization IDs), enforcing type (e.g., integer), length, and format constraints before they reach the data access layer.
  • Centralize query construction through a data access layer or ORM that enforces binding rather than manual string assembly.
  • Restrict database privileges for the CRM application account to the minimum needed (no superuser or dangerous administrative permissions), limiting the blast radius of possible injection.
  • Implement a general secure coding guideline that treats all inbound HTTP parameters as untrusted and requires defensive patterns before use in downstream components.

How teams detect issues like this

Detection can combine code-level analysis with runtime behavior monitoring:

  • Static analysis and code review:
  • Search for direct use of HTTP parameters (e.g., $_GET['gblOrgID'] or framework equivalents) in SQL construction routines.
  • Flag any dynamic SQL concatenation, especially around endpoints in /tools/ and the jxf_dump_systable functionality.
  • Enforce code review checklists that require parameterized queries for all database access.
  • Automated tooling:
  • Use static application security testing (SAST) tools configured with rules for SQL injection patterns (CWE-89/CWE-74).
  • Integrate these tools into CI to block new instances of string-based query building.
  • Dynamic and operational monitoring:
  • Employ web application firewalls (WAFs) with rules that detect common SQL injection signatures in the gblOrgID parameter.
  • Monitor database logs for anomalous queries, unexpected errors, or unusual patterns originating from the CRM application account.
  • Security testing:
  • Include this endpoint in regular penetration tests and DAST scans, focusing on inputs that influence system-table access and dumps.

Sources

SourceLink
gist.github.comgist.github.com/jikdarren/67ba9fdd2a8b619fc9a370102c317971
vuldb.comvuldb.com/cve/CVE-2026-11456
vuldb.comvuldb.com/submit/828375
vuldb.comvuldb.com/vuln/369075
vuldb.comvuldb.com/vuln/369075/cti

Frequently asked

questions

Yes, it can be exploited remotely if the vulnerable /tools/jxf_dump_systable.php endpoint is network-accessible, as attackers only need to send crafted HTTP GET requests with a manipulated gblOrgID parameter.

Public information does not confirm whether authentication is required, but SQL injection issues of this kind often occur on endpoints that may be reachable to low-privileged or even unauthenticated users.

The key requirement is the ability to reach the endpoint and control the gblOrgID parameter.

The most robust pattern is to refactor all affected database calls to use parameterized queries or a safe ORM abstraction, combined with strict type and format validation for gblOrgID and similar parameters, completely removing string concatenation from query construction.

Preventive measures include institutionalizing secure coding standards around database access, mandating prepared statements, integrating SAST/DAST tools in the development pipeline, conducting regular security-focused code reviews, and limiting database privileges so that any future injection has minimal impact.

Find out what's already
exploitable in your codebase.