/

CVE-2026-75498

Severity:

HIGH RISK

(7.2)

SQL Injection (CWE-89) in Webkul QloApps Address.php

CVE-2026-75498

Awaiting Analysis

Vulnerability type

Category:

SQL Injection

CWE:

CWE-89

Impact:

Database compromise and unauthorized data access

Severity:

HIGH RISK

(7.2)

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

Webkul QloApps fails to validate request parameters before using them in a database query, allowing a crafted value in the bo_query parameter to alter SQL behavior. A remote attacker who is authenticated and has administrative privileges may exploit this weakness to access or modify database information.

Affected context

The vulnerability occurs in Webkul QloApps when the administrative Address.php functionality processes the bo_query request parameter and incorporates it into a database query without adequate validation or parameterization. Exploitation generally depends on the attacker reaching the administrative endpoint with valid administrative privileges.

Exploit preconditions

  • Attack surface: Remote administrative web application endpoint
  • Required access: Authenticated account with administrative privileges
  • Trigger point: Processing of the bo_query parameter in Address.php
  • Why exploitation is possible: Request-controlled data can influence SQL query construction without sufficient validation or safe parameter binding

Why this happens

The underlying bug is an SQL injection condition caused by treating request parameters as trusted database query content. When application code concatenates or otherwise embeds attacker-controlled input into SQL statements instead of using parameterized queries, the input can change the intended query structure. This behavior maps to CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection').

Potential impact

  • An attacker may read sensitive database records
  • An attacker could alter or delete application data
  • Database credentials or other stored secrets may be exposed
  • Application integrity and administrative records may be compromised
  • The vulnerability can support further compromise of connected systems, depending on database permissions

General mitigation guidance

Mitigation generally centers on preventing request data from becoming executable SQL syntax.

Common defensive patterns include:

  • Use parameterized queries or prepared statements for all database operations
  • Replace dynamic query construction with allowlisted query options and typed inputs
  • Apply server-side validation at the request boundary
  • Enforce least-privilege permissions for the application database account
  • Avoid exposing administrative database-query functionality unless it is strictly required
  • Centralize database access controls and encode safe query-building practices into shared components

How teams detect issues like this

Organizations commonly detect SQL injection risks through:

  • Static analysis rules identifying string concatenation or interpolation in SQL statements
  • Code review checks for request parameters passed directly to database APIs
  • Dynamic application testing that submits unexpected SQL metacharacters to administrative inputs
  • Web application firewall or gateway policies monitoring suspicious query syntax
  • Database audit logging for unusual statements, access patterns, or administrative data changes
  • Automated security review tools that flag missing parameter binding and weak input validation

Sources

SourceLink
github.comgithub.com/Qloapps/QloApps/pull/1783/changes/123c97c110b7053ea3297d8e58fe95b3c3536560
raw.githubusercontent.comraw.githubusercontent.com/cisagov/CSAF/develop/csaf_files/IT/white/2026/va-26-237-01.json
cve.orgcve.org/CVERecord?id=CVE-2026-75498

Frequently asked

questions

Yes, exploitation can occur through the remote administrative web interface, but the attacker generally needs valid administrative authentication.

The described attack requires an authenticated account with administrative privileges and access to the vulnerable functionality.

Use parameterized database queries, validate inputs against strict expected types or allowlists, and avoid constructing SQL statements directly from request values.

Combine secure database-access abstractions with code review, static analysis, dynamic testing, least-privilege database accounts, and monitoring of administrative requests and database activity.

Find out what's already
exploitable in your codebase.