/

CVE-2025-61546

Severity:

CRITICAL RISK

(9.1)

Improper Input Validation in Print Shop Pro WebDesk Cart

CVE-2025-61546

Modified

Vulnerability type

Category:

Improper Input Validation

CWE:

CWE-20

Impact:

Integrity Compromise and Financial Manipulation

Severity:

CRITICAL RISK

(9.1)

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

An improper input validation flaw in Print Shop Pro WebDesk's cart pricing endpoint allows attackers to submit negative item quantities when calculating unit prices.

By bypassing client-side controls and sending crafted requests directly to the /PSP/appNET/Store/CartV12.aspx/GetUnitPrice endpoint, an attacker can create financial discrepancies, such as obtaining credit or reducing charges, during the purchase process.

Affected context

This vulnerability affects deployments of edu Business Solutions Print Shop Pro WebDesk (version 18.34) that rely primarily on client-side validation to enforce shopping cart constraints.

The issue occurs in the server-side handling of the /PSP/appNET/Store/CartV12.aspx/GetUnitPrice endpoint, where item quantities are processed without robust server-side range checks.

Environments in which users can interact with the WebDesk storefront from untrusted networks, or where automated scripts can reach this endpoint, are particularly exposed to abuse.

Exploit preconditions

  • Attack surface: Public or internally accessible web endpoint at /PSP/appNET/Store/CartV12.aspx/GetUnitPrice.
  • Required access: Ability to interact with the web application as a shopper or unauthenticated user, depending on deployment configuration.
  • Trigger point: Submission of crafted HTTP requests (e.g., via browser dev tools, proxies, or scripts) specifying negative quantities or otherwise invalid numeric values.
  • Why exploitation is possible: The application trusts client-side validation logic and does not enforce strict server-side validation or sanity checks for quantity values, allowing negative quantities to influence price calculations and order totals.

Why this happens

The underlying bug belongs to CWE-20: Improper Input Validation.

Business-critical parameters (such as quantity) are enforced only through client-side checks (e.g., HTML controls or JavaScript), while the server logic that calculates unit prices and totals accepts and processes unvalidated values.

Abstractly, this pattern arises whenever server-side code assumes that user-supplied numeric fields will always be well-formed and within expected ranges because "the UI enforces it," rather than performing independent validation at the trust boundary.

As a result, malicious clients that bypass or disable the front-end logic can send out-of-range values that the backend uses directly in pricing and financial calculations.

Potential impact

  • Attackers may reduce or negate charges by using negative quantities in cart calculations.
  • Users could effectively generate credit or refunds that are not actually owed.
  • Financial records, invoices, and accounting data can become inconsistent or inaccurate.
  • Reporting systems may show distorted sales, inventory usage, or revenue figures.
  • Abuse at scale could cause significant financial loss or reconciliation overhead.

General mitigation guidance

Mitigation efforts typically focus on moving critical validation to the server and enforcing strict business rules for financial parameters:

  • Validate all quantity and price-related parameters on the server side, including checks for non-negativity, reasonable upper bounds, and correct data types.
  • Treat client-side controls as a user-experience enhancement only, not a security boundary.
  • Implement centralized validation routines for financial and cart-related operations so every entry point (e.g., price calculators, order submission APIs, cart update endpoints) uses the same constraints.
  • Enforce business invariants such as "quantities must be positive integers" before any pricing or accounting logic is executed.
  • Apply least-privilege principles in pricing and discount logic, ensuring that user-controlled inputs cannot directly alter sensitive financial fields without validation and business rule checks.

How teams detect issues like this

Organizations can identify similar issues by combining code inspection with behavioral testing:

  • Static analysis: Search for controller or API methods that trust client-side validation and lack explicit server-side checks for numeric fields used in pricing or accounting.
  • Code review signals: Pay special attention to endpoints that consume quantity, price, or discount parameters and directly apply them in calculations without validating ranges and constraints.
  • Security testing: Use automated or manual web testing to submit negative or extreme values for quantities and other numeric parameters, monitoring for unexpected cart totals or credits.
  • Policy enforcement: Establish development standards that require server-side validation for all user-controlled inputs, especially where financial or transactional logic is involved, and enforce these policies via CI checks or security gates.

Sources

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

Frequently asked

questions

The vulnerability is exploitable by anyone who can reach the affected endpoint and manipulate requests, often through browser developer tools or intercepting proxies, regardless of what restrictions the front-end UI appears to enforce.

That depends on how the storefront is configured, but in many cases, only the level of access needed to use the shopping cart is required. If the endpoint is reachable to unauthenticated users, the attack can be performed without logging in.

Implement strict server-side validation for all financial parameters, particularly quantities, ensuring they are positive and within expected limits before performing any pricing or order calculations. Client-side checks can remain for usability but must not be relied on for security.

Treat every client-supplied value as untrusted, enforce centralized server-side validation for business-critical data, and incorporate targeted tests and code review checklists to verify that financial and transactional logic never relies solely on UI-level controls.

Find out what's already
exploitable in your codebase.