/

CVE-2026-15517

Severity:

HIGH RISK

(7.3)

SQL Injection (CWE-89) in Jinher OA PlanGiveOut.aspx

CVE-2026-15517

Deferred

Vulnerability type

Category:

SQL Injection

CWE:

CWE-74, CWE-89

Impact:

Data Exposure and Database Compromise

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

Jinher OA 1.0 contains a SQL injection flaw in the PlanGiveOut.aspx endpoint where user-supplied data is incorporated into database queries without proper sanitization.

An attacker sending crafted httpOID parameters over the network can manipulate backend SQL statements, potentially accessing or modifying sensitive data in the application database.

Affected context

The vulnerability appears within the Jinher OA 1.0 web application, specifically in functionality exposed by /C6/JHSoft.Web.PlanSummarize/PlanGiveOut.aspx.

It arises when the application builds SQL queries using the httpOID parameter, or related request data, without robust validation or parameterization.

This typically affects deployments where the application server has direct access to a relational database and trusts incoming HTTP parameters for query construction.

Exploit preconditions

  • Attack surface: Public or internal web endpoint /C6/JHSoft.Web.PlanSummarize/PlanGiveOut.aspx reachable over HTTP/HTTPS.
  • Required access: Ability to send requests to the application (usually remote, potentially unauthenticated depending on deployment).
  • Trigger point: Submission of crafted httpOID values or related parameters that are used directly in SQL query construction.
  • Why exploitation is possible: The server-side code appears to concatenate or interpolate user input into SQL statements without using parameterized queries or consistent input validation, allowing attackers to alter the intended query structure.

Why this happens

The underlying bug class aligns with CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection') and CWE-74: Improper Neutralization of Special Elements in Output.

Application logic likely constructs SQL commands by embedding the httpOID argument directly into query strings, treating it as trusted data.

Without parameterized statements or robust neutralization, control characters and SQL syntax in user input are interpreted by the database engine, transforming data input into query logic and enabling injection.

Potential impact

  • Attackers may read sensitive records they are not authorized to access.
  • Malicious users could modify, insert, or delete data in the underlying database.
  • The application's integrity can be compromised, leading to altered business workflows or falsified records.
  • Depending on database configuration, attackers might escalate to executing database-native procedures or accessing adjacent systems.

General mitigation guidance

Mitigation generally focuses on eliminating direct concatenation of user input into SQL statements and tightening trust boundaries around request parameters.

Secure design patterns include:

  • Using parameterized queries or prepared statements for all database interactions, ensuring user data is treated strictly as values.
  • Applying strict input validation for identifiers like httpOID, limiting them to expected formats (e.g., numeric IDs or constrained UUIDs).
  • Centralizing database access logic to enforce consistent query-building practices and prevent ad hoc string-based SQL.
  • Applying least-privilege to database accounts so that even if injection is attempted, accessible operations and data are minimized.

How teams detect issues like this

Detection typically relies on combining code-level analysis with operational monitoring:

  • Static analysis rules that flag dynamic SQL construction using request parameters, string concatenation, or format operations.
  • Targeted code reviews of data access layers to look for inline SQL strings that incorporate user input without binding parameters.
  • Security testing (including automated scanners and manual penetration tests) focused on inputs like httpOID that influence query behavior.
  • Runtime monitoring and database logging for anomalous queries, unexpected UNIONs, tautological WHERE clauses, or sudden changes to critical tables.

Sources

SourceLink
github.comgithub.com/weini587/CVE/issues/1
vuldb.comvuldb.com/cve/CVE-2026-15517
vuldb.comvuldb.com/submit/849470
vuldb.comvuldb.com/vuln/377846
vuldb.comvuldb.com/vuln/377846/cti

Frequently asked

questions

Exploitability depends on whether the vulnerable endpoint is exposed to untrusted networks and whether access controls are in place, but the flaw is inherently remotely triggerable via HTTP requests.

An attacker typically needs network access to the Jinher OA application and the ability to send requests to PlanGiveOut.aspx; in some deployments this may require authentication, in others it may be reachable without login.

The most robust fix is to migrate all affected queries to parameterized statements or prepared queries, combined with strict validation of the httpOID and related inputs so that they cannot alter SQL structure.

Standardize on secure database access patterns, enforce coding guidelines that prohibit dynamic SQL built from user input, integrate static analysis and security reviews into the development lifecycle, and ensure that new endpoints undergo input validation and security testing.

Find out what's already
exploitable in your codebase.