/

CVE-2026-29099

Severity:

HIGH RISK

(8.8)

SQL Injection in SuiteCRM OutboundEmail retrieve() Function

CVE-2026-29099

Analyzed

Vulnerability type

Category:

SQL Injection

CWE:

CWE-89

Impact:

Authenticated SQL Injection with Arbitrary Data Access

Severity:

HIGH RISK

(8.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

SuiteCRM contains a SQL injection vulnerability in the retrieve() function of include/OutboundEmail/OutboundEmail.php, where the user-controlled $id parameter is not properly neutralized.

When reached via specific EmailUIAjax flows in the Emails module, an authenticated user can inject SQL through this parameter and read arbitrary data from the CRM database, including user details and password hashes.

Affected context

The vulnerability occurs in SuiteCRM deployments using the OutboundEmail functionality where the retrieve() method is called with user-controlled input.

It is present in major versions 7.15 and 8.9, specifically in code paths accessible via the EmailUIAjax action on the Emails module that invoke retrieve() without adding their own quoting or sanitization.

The issue is exposed in authenticated application sessions, where users can trigger these paths with crafted identifiers that are passed directly into SQL queries.

Exploit preconditions

  • Attack surface: Web application, via HTTP requests to SuiteCRM's Emails module using the EmailUIAjax action.
  • Required access: Valid authenticated SuiteCRM user account with access to email-related features that ultimately call OutboundEmail::retrieve().
  • Trigger point: Supplying a crafted $id value that flows through EmailUIAjax handlers into the retrieve() method without proper escaping or parameterization.
  • Why exploitation is possible: The retrieve() implementation trusts callers to sanitize the $id parameter. In the identified paths, no such sanitization is applied, so attacker-controlled input is concatenated into SQL, enabling injection.

Why this happens

The core defect is a classic SQL injection flaw as described in CWE-89: Improper Neutralization of Special Elements used in an SQL Command.

The retrieve() function constructs SQL queries using the $id field but relies on callers to quote and sanitize this value instead of enforcing safe handling inside the function itself.

In at least two code locations reachable via EmailUIAjax, the caller passes user-controlled data directly into retrieve() without using parameterized queries, escaping, or validation.

This design pattern—splitting responsibility for input sanitization across multiple layers—leads to inconsistent defenses and allows crafted identifiers to alter the structure of the underlying SQL.

Potential impact

  • An authenticated user may read arbitrary records from any accessible database table.
  • An attacker could retrieve sensitive CRM data such as contacts, leads, and customer records.
  • User account information, including password hashes, could be extracted for offline cracking.
  • SQL queries could be manipulated to bypass certain logical restrictions or filters at the application layer.
  • In some configurations, SQL injection might be extended to modify data or affect application integrity.

General mitigation guidance

Effective mitigation for this pattern focuses on centralizing and enforcing safe SQL construction:

  • Treat all identifiers and parameters consumed by retrieve() and similar data-access functions as untrusted, enforcing sanitization and parameterization within those functions rather than delegating to callers.
  • Replace dynamic string concatenation in query construction with prepared statements or ORM abstractions that bind parameters safely.
  • Introduce strict validation on ID-like parameters (e.g., restricting them to expected formats such as UUIDs or specific fixed patterns) before they are passed into the database layer.
  • Adopt a coding guideline that all database interaction must go through vetted helper APIs that automatically quote parameters and prevent raw injection.
  • Apply least-privilege database accounts where possible, so that even if a query is manipulated, its scope is limited.

How teams detect issues like this

Organizations can identify similar SQL injection risks through layered detection approaches:

  • Static analysis: Configure rules to flag direct string concatenation into SQL statements, calls to database APIs with raw input, and data-access methods (like retrieve()) that accept unvalidated identifiers.
  • Code review: During manual review, trace the flow of user-supplied parameters (e.g., from AJAX handlers such as EmailUIAjax) into database queries, checking that all paths use parameterized statements.
  • Security tests: Use automated and manual web application testing to probe ID parameters and AJAX endpoints for anomalous SQL behavior, monitoring database error responses and timing differences.
  • Policy enforcement: Establish internal policies that disallow raw SQL construction in controllers or UI handlers, routing all database operations through centralized, security-hardened repository or ORM layers.

Sources

SourceLink
docs.suitecrm.comdocs.suitecrm.com/admin/releases/7.15.x
github.comgithub.com/SuiteCRM/SuiteCRM/security/advisories/GHSA-38rf-h37x-7767

Frequently asked

questions

Yes, if the SuiteCRM instance is exposed over the internet and an attacker can obtain valid credentials. The attack is performed through authenticated web requests to the affected email-related endpoints.

It requires an authenticated user account with access to the Emails module and associated AJAX functionality. Elevated privileges may increase the value of accessible data, but the injection itself does not necessarily require administrative rights.

Move all responsibility for sanitizing and binding query parameters into the data-access layer. Use prepared statements or ORM methods in retrieve() (and similar functions), and ensure no call sites can pass raw input directly into SQL strings.

Standardize on parameterized queries and vetted database abstractions, prohibit ad hoc SQL concatenation in application code, validate all user-supplied identifiers against strict schemas, and integrate static analysis plus security-focused code review into the development workflow.

Find out what's already
exploitable in your codebase.