Skip to main content
Vulnerability Database/CVE-2026-109169

CVE-2026-109169: LogicalDOC Community Edition SQL Injection

CVE-2026-109169 is a SQL injection flaw in LogicalDOC Community Edition that lets authenticated attackers extract sensitive data like usernames and password hashes. This article covers technical details, affected versions, and mitigation.

Published:

Disclaimer: This content was generated using AI. While we strive for accuracy, please verify critical information with official sources.

Sources: National Vulnerability Database, CISA KEV, Exploit-DB

CVE-2026-109169 Overview

CVE-2026-109169 is a SQL injection vulnerability [CWE-89] affecting LogicalDOC Community Edition through version 9.3. The flaw resides in the TagsDataServlet component, where the firstLetter parameter is concatenated directly into a SQL query without parameterization. Authenticated low-privileged attackers can inject UNION SELECT statements that are reflected in the XML tag list returned by the servlet. This allows extraction of sensitive data from the ld_user table, including usernames, email addresses, and password hashes.

Critical Impact

Authenticated attackers with low privileges can exfiltrate user credentials, including password hashes, enabling account takeover and lateral movement across the document management platform.

Affected Products

  • LogicalDOC Community Edition versions through 9.3
  • TagsDataServlet component in logicaldoc-webapp
  • HibernateDocumentDAO tag search functionality in logicaldoc-core

Discovery Timeline

  • 2026-10-12 - CVE-2026-109169 published to NVD
  • 2026-10-13 - Last updated in NVD database

Technical Details for CVE-2026-109169

Vulnerability Analysis

The vulnerability exists in LogicalDOC's tag retrieval logic. The TagsDataServlet accepts a firstLetter HTTP parameter intended to filter tags by their leading character. The servlet passes this value to HibernateDocumentDAO, which builds a raw SQL query by string formatting rather than binding the parameter. The query result is serialized into an XML tag list and returned to the caller, providing a convenient channel to exfiltrate injected UNION SELECT output.

Because the response surface mirrors the injected columns, attackers can enumerate arbitrary tables. The ld_user table is a priority target because it stores authentication material. Successful exploitation yields usernames, email addresses, and password hashes that can be subjected to offline cracking.

Root Cause

The root cause is unsafe use of Java string formatting to assemble a SQL statement. The pre-patch code applied " and lower(ld_tag) like '%s%%' ".formatted(firstLetter.toLowerCase()) directly to the query builder. Lowercasing the input provides no sanitization against SQL metacharacters, and no prepared statement or parameter binding was used before executing the query.

Attack Vector

Exploitation requires network access to the LogicalDOC web application and a valid low-privileged user account. The attacker submits a crafted firstLetter value to the TagsDataServlet endpoint. The injected payload closes the LIKE clause and appends a UNION SELECT that targets columns in ld_user. The resulting XML tag list carries the extracted credential data back to the attacker.

java
// Patch diff from HibernateDocumentDAO.java (line 691)
 StringBuilder query = new StringBuilder("SELECT ld_count, ld_tag from ld_uniquetag where 1 = 1 ");
 if (StringUtils.isNotEmpty(firstLetter))
-    query.append(" and lower(ld_tag) like '%s%%' ".formatted(firstLetter.toLowerCase()));
+    query.append(" and lower(ld_tag) like :tagLike ");
 if (tenantId != null)
     query.append(AND_LD_TENANTID_D.formatted(tenantId));

-query(query.toString(), new RowMapper<Object>() {
+query(query.toString(), Map.of("tagLike", "%s%%".formatted(firstLetter.toLowerCase())),
+        new RowMapper<Object>() {
     @Override
     public Object mapRow(ResultSet rs, int rowNumber) throws SQLException {
         Long value = rs.getLong(1);
         String key = rs.getString(2);
         map.put(key, value);
         return null;
     }
 }, null);

Source: LogicalDOC Commit 8428bfb. The fix replaces the inline string format with a named parameter :tagLike bound through the DAO's parameterized query API.

Detection Methods for CVE-2026-109169

Indicators of Compromise

  • HTTP requests to TagsDataServlet containing SQL keywords such as UNION, SELECT, --, or /* inside the firstLetter parameter.
  • XML tag list responses containing unexpected values resembling password hash formats or email addresses.
  • Database query logs showing SELECT ld_count, ld_tag from ld_uniquetag statements with appended UNION clauses.

Detection Strategies

  • Deploy a Web Application Firewall (WAF) rule that inspects the firstLetter query parameter for SQL metacharacters and UNION tokens.
  • Enable verbose SQL query logging on the Hibernate layer and alert on queries referencing ld_uniquetag with embedded UNION or ld_user references.
  • Correlate authenticated session activity against anomalous access patterns to the tags endpoint for the same user account.

Monitoring Recommendations

  • Monitor application access logs for repeated requests to the tags data endpoint from a single authenticated session.
  • Track outbound response sizes from TagsDataServlet; abnormally large XML payloads can indicate bulk data exfiltration.
  • Audit the ld_user table for unexpected read access patterns through database activity monitoring.

How to Mitigate CVE-2026-109169

Immediate Actions Required

  • Upgrade LogicalDOC Community Edition beyond version 9.3 or apply the fix from commit 8428bfb93f89ab5773019299d17d643c075c4aee to patched source builds.
  • Rotate credentials for all LogicalDOC user accounts, assuming password hashes may have been exfiltrated.
  • Restrict network access to the LogicalDOC web interface to trusted internal networks or VPN users only.

Patch Information

The maintainers fixed the vulnerability by replacing the inline SQL string formatting with a named parameter binding in HibernateDocumentDAO.java. Review the full patch in the LogicalDOC Commit Update and the related LogicalDOC Community Discussion. Additional context is available in the VulnCheck SQL Injection Advisory.

Workarounds

  • Add a reverse proxy or WAF rule that rejects requests to TagsDataServlet where the firstLetter parameter exceeds a single alphanumeric character.
  • Temporarily revoke access to the tags functionality for low-privileged user roles until the patch is deployed.
  • Enforce database-level least privilege so the LogicalDOC service account cannot read sensitive columns beyond its functional requirements.
bash
# Example WAF rule (ModSecurity) to block SQL injection in firstLetter parameter
SecRule ARGS:firstLetter "@rx (?i)(union|select|--|/\*|')" \
    "id:1091690,phase:2,deny,status:403,log,\
    msg:'CVE-2026-109169 LogicalDOC TagsDataServlet SQLi attempt'"

Disclaimer: This content was generated using AI. While we strive for accuracy, please verify critical information with official sources.

Sources: National Vulnerability Database, CISA KEV, Exploit-DB

Experience the Most Advanced Cybersecurity Platform

See how the world’s most intelligent, autonomous cybersecurity platform can protect your organization today and into the future.