/

CVE-2026-11435

Severity:

HIGH RISK

(7.3)

SQL Injection (CWE-89) in Jinher OA nextselectplan.aspx httpOID Parameter

CVE-2026-11435

Deferred

Vulnerability type

Category:

SQL Injection

CWE:

CWE-74, CWE-89

Impact:

Data Exposure and Manipulation via SQL Injection

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 vulnerability in the nextselectplan.aspx endpoint via the httpOID parameter, where attacker-controlled input is incorporated into database queries without proper sanitization.

A remote attacker can send crafted HTTP requests to manipulate backend SQL queries, potentially accessing, modifying, or deleting sensitive data in the application database.

Affected context

The vulnerability resides in the Jinher OA 1.0 web application, specifically in the nextselectplan.aspx page that processes the httpOID parameter from HTTP requests.

It appears when user-supplied values are concatenated directly into SQL statements or are insufficiently parameterized.

Any deployment that exposes this endpoint over a network and relies on a relational database backend may be affected, particularly when default or weak database hardening practices are in place.

Exploit preconditions

  • Attack surface: HTTP interface of the Jinher OA web server, targeting nextselectplan.aspx.
  • Required access: Remote network access to the application; no valid user account may be required if the vulnerable page is reachable anonymously.
  • Trigger point: Submission of a crafted httpOID parameter in a GET or POST request that is used in SQL queries without proper escaping or binding.
  • Why exploitation is possible: The application builds SQL statements using untrusted input, violating the principle of using parameterized queries and server-side validation, which allows the attacker to alter query structure.

Why this happens

This issue is rooted in improper construction of SQL queries with untrusted input, aligning primarily with CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection').

The httpOID parameter is likely interpolated directly into an SQL string or passed through only superficial validation, allowing injection of SQL control characters and keywords.

At a broader level, this reflects CWE-74: Improper Neutralization of Special Elements in Output Used by a Downstream Component, where external input is not neutralized before being consumed by the database engine, which interprets it as part of executable SQL rather than as data.

Potential impact

  • Attackers could read or enumerate sensitive records from the application database, including business or personal information.
  • Malicious users may alter or delete data, impacting integrity of workflow, planning, or other OA records.
  • The vulnerability could be used to create or escalate application accounts if authentication data is stored in the same database.
  • In some configurations, attackers might execute database-native functions leading to file access or further compromise of the underlying host.
  • Application availability could be affected by destructive queries or by forcing expensive operations that degrade performance.

General mitigation guidance

Effective mitigation focuses on eliminating direct string concatenation of SQL queries and treating all external input as untrusted:

  • Adopt parameterized queries or prepared statements for all database interactions; bind the httpOID value as a typed parameter rather than concatenating strings.
  • Apply strict server-side validation and normalization to identifier-like parameters, accepting only expected formats (e.g., numeric IDs or fixed patterns).
  • Centralize data access logic to enforce consistent query-building patterns and to avoid ad hoc SQL across pages and components.
  • Use least-privilege database accounts so that even if a query is manipulated, accessible operations and tables are limited.
  • Introduce a secure coding standard that explicitly forbids dynamic SQL construction with raw HTTP parameters and promote secure frameworks/ORMs that handle escaping by default.

How teams detect issues like this

SQL injection weaknesses can often be detected through a combination of code-centric and runtime approaches:

  • Perform static analysis to flag string-based SQL construction, especially where HTTP parameters (like httpOID) flow into query-building functions.
  • During code review, look for inline SQL in ASP.NET code-behind or data access layers that concatenate user input or rely on manual escaping routines.
  • Configure dynamic security testing (DAST) to send crafted payloads to the nextselectplan.aspx endpoint and monitor for error messages, unusual responses, or database error signatures.
  • Implement database monitoring and query logging to detect anomalous queries, such as unexpected UNIONs, subqueries, or comment patterns that indicate tampering.
  • Use automated secure code scanning tools integrated into CI to enforce policies around mandatory use of parameterized queries.

Sources

SourceLink
github.comgithub.com/Mr-Elymas/cve_submit/issues/1
vuldb.comvuldb.com/cve/CVE-2026-11435
vuldb.comvuldb.com/submit/822114
vuldb.comvuldb.com/vuln/369015
vuldb.comvuldb.com/vuln/369015/cti

Frequently asked

questions

Yes. The issue exists in a web-accessible ASPX page, so a remote attacker who can reach the Jinher OA 1.0 application over the network can attempt to exploit it by sending crafted HTTP requests.

Not necessarily. If nextselectplan.aspx is accessible without authentication, exploitation can occur anonymously. If it is behind a login, any user who can reach the page may be able to exploit the flaw.

Refactor the affected code to use parameterized queries or a higher-level ORM that enforces bound parameters, and ensure httpOID is treated strictly as data with appropriate type and range checks, never as part of a concatenated SQL string.

Establish secure coding guidelines that mandate parameterized queries, introduce automated checks for dynamic SQL, train developers on injection risks, and integrate static and dynamic security testing into the development lifecycle to catch injection patterns before release.

Find out what's already
exploitable in your codebase.