/

CVE-2025-61548

Severity:

CRITICAL RISK

(9.8)

SQL Injection in Print Shop Pro WebDesk CartV12

CVE-2025-61548

Modified

Vulnerability type

Category:

SQL Injection

CWE:

CWE-89

Impact:

Arbitrary SQL Command Execution and Data Compromise

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

A critical SQL injection vulnerability exists in the hfInventoryDistFormID parameter of the /PSP/appNET/Store/CartV12.aspx/GetUnitPrice endpoint in edu Business Solutions Print Shop Pro WebDesk 18.34.

Because user-controlled data is inserted directly into SQL statements without parameterization or proper escaping, a remote attacker can manipulate database queries and execute arbitrary SQL commands when this endpoint is invoked.

Affected context

The vulnerability occurs in the WebDesk web application of Print Shop Pro, specifically in the CartV12 functionality that retrieves unit pricing via the GetUnitPrice endpoint.

It is present where:

  • The application exposes /PSP/appNET/Store/CartV12.aspx/GetUnitPrice over HTTP(S)
  • The hfInventoryDistFormID parameter is accepted from client requests
  • Server-side code concatenates this parameter directly into SQL queries to look up pricing or inventory data

In this context, any environment where this endpoint is reachable and tied to a relational database is potentially affected.

Exploit preconditions

  • Attack surface: Public or internal web interface via HTTP(S) requests to /PSP/appNET/Store/CartV12.aspx/GetUnitPrice
  • Required access: Ability to send crafted requests to the WebDesk application (typically unauthenticated or low-privilege web access, depending on deployment)
  • Trigger point: Processing of the hfInventoryDistFormID parameter when the backend constructs and executes a SQL query
  • Why exploitation is possible: The application dynamically builds SQL statements using string concatenation that incorporates hfInventoryDistFormID without parameter binding, escaping, or server-side validation, allowing attacker-supplied tokens to alter the structure of the SQL query.

Why this happens

This issue stems from building SQL queries by concatenating raw user input into query strings instead of using parameterized statements or stored procedures with proper binding.

The hfInventoryDistFormID value is trusted as-is and inserted into the SQL command text, so the database engine interprets malicious fragments as part of the query logic rather than as data.

This pattern aligns with CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection'), in which insufficient input neutralization allows attackers to modify query semantics.

Potential impact

  • Extraction of sensitive data from the database (customer information, order details, or internal records)
  • Modification or deletion of database contents, including pricing, inventory, or transactional data
  • Creation of new accounts or elevation of privileges via manipulation of authentication or authorization tables
  • Disruption of application availability by issuing destructive or resource-intensive SQL commands
  • Potential pivoting to underlying host or other systems if the database platform supports command execution or external calls

General mitigation guidance

Effective mitigation generally focuses on treating all incoming parameters as untrusted and enforcing strict separation between query logic and data.

Common defensive patterns include:

  • Using parameterized queries / prepared statements for all database access involving user-controlled values, including hfInventoryDistFormID
  • Applying server-side validation and normalization on input parameters to enforce expected types, ranges, and formats before they reach the data access layer
  • Centralizing data access logic in a controlled repository or service layer where secure query construction patterns are consistently applied
  • Configuring database accounts with least privilege, limiting the impact of any injected queries (read-only where feasible for lookup operations like GetUnitPrice)
  • Employing application-wide coding standards and libraries that make secure-by-default query execution easy and string-based concatenation unusual

How teams detect issues like this

Detecting and managing this class of vulnerability typically involves both preventive and detective controls:

  • Static analysis: Configure SAST tools or linters to flag string concatenation used to build SQL queries and highlight calls where user input flows into query execution APIs without parameter binding.
  • Code review: During peer review, trace the flow of web parameters such as hfInventoryDistFormID into the data access layer, watching for inline SQL strings, dynamic WHERE clauses, or ad-hoc query construction.
  • Security testing: Use targeted dynamic application security testing (DAST) or manual penetration testing to send benign injection probes and observe anomalies in responses, errors, or logs for endpoints like GetUnitPrice.
  • Runtime monitoring: Enable database and application logging for unusual query patterns, unexpected error messages, and high-risk SQL constructs (e.g., multiple statements, UNION queries, or system table access) originating from web endpoints.

Sources

SourceLink
github.comgithub.com/chndlrx/vulnerability-disclosures/tree/main/CVE-2025-61548

Frequently asked

questions

Yes. An attacker who can reach the WebDesk application over the network and send requests to /PSP/appNET/Store/CartV12.aspx/GetUnitPrice can attempt SQL injection via the hfInventoryDistFormID parameter.

That depends on how the application is deployed and whether this endpoint is gated by authentication. If accessible to unauthenticated users or low-privilege roles, exploitation may be possible with minimal access, provided the endpoint can be invoked.

Refactor the data access code so that all database interactions use parameterized queries or stored procedures, binding hfInventoryDistFormID and any other user-derived values as parameters rather than concatenating them into SQL strings. Combine this with strict input validation to enforce expected formats.

Adopt a secure coding standard that prohibits raw SQL string concatenation with user input, enforce it via static analysis and code review, use data access libraries that encourage parameterization by default, and ensure developers receive regular training on injection risks and safe query construction patterns.

Find out what's already
exploitable in your codebase.