/

CVE-2026-25236

Severity:

CRITICAL RISK

(9.8)

SQL Injection in PEAR Karma Queries

CVE-2026-25236

Analyzed

Vulnerability type

Category:

SQL Injection

CWE:

CWE-89

Impact:

Arbitrary SQL Query Manipulation and Potential Database 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 SQL injection vulnerability in PEAR's karma query handling allows unsafe literal substitution into an SQL IN (...) clause, enabling attackers to manipulate database queries.

When user-controlled values flow into these karma queries without proper parameterization or validation, an attacker may execute arbitrary SQL, potentially leading to data exposure, modification, or full database compromise.

Affected context

This vulnerability affects applications that use PEAR as a framework and depend on its karma-related functionality for managing contributor or user reputation/permissions.

It becomes relevant when:

  • PEAR's karma features are enabled or indirectly invoked,
  • User-supplied or otherwise untrusted data is used to build lists for IN (...) filters, and
  • The application relies on the underlying database for authorization, user metadata, or other sensitive operations.

Exploit preconditions

  • Attack surface: Any code path that triggers PEAR karma queries and incorporates external (user-controlled or otherwise untrusted) identifiers into an IN (...) list.
  • Required access: Ability to influence parameters that are used in PEAR karma lookups (e.g., via HTTP request parameters, form inputs, or API calls).
  • Trigger point: Execution of a karma-related SQL query that interpolates these values directly into the IN (...) clause without parameter binding.
  • Why exploitation is possible: The query builder uses string concatenation or unsafe literal substitution instead of prepared statements, allowing crafted input to break out of the intended list and inject arbitrary SQL fragments.

Why this happens

The underlying bug is an instance of CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection').

PEAR's karma query logic constructs an IN (...) clause by directly embedding externally influenced values into the SQL string.

Rather than using positional or named parameters with prepared statements, it relies on concatenated literals, so characters like quotes, commas, or parentheses are not reliably neutralized.

This pattern allows an attacker to alter the structure of the query, append new conditions, or inject additional SQL statements, depending on the database engine and configuration.

Potential impact

  • Retrieval of sensitive data from other tables the application account can access
  • Modification or deletion of records related to users, permissions, or application data
  • Escalation or manipulation of karma, roles, or privileges stored in the database
  • Creation of new privileged accounts or backdoor entries in application tables
  • In some environments, execution of database-level commands that could impact availability or underlying infrastructure

General mitigation guidance

Effective mitigation focuses on eliminating dynamic SQL string construction for the IN (...) clause and similar patterns:

  • Use prepared statements with bound parameters for all values, including those used in IN lists (e.g., expanding to a controlled number of placeholders).
  • Treat all karma-related identifiers and list elements as untrusted and validate them for expected type and format (e.g., strict integer or whitelist of allowed tokens).
  • Centralize query construction through a data access layer or ORM that enforces parameterization by default and discourages raw string concatenation.
  • Apply the principle of least privilege to the database account used by PEAR-backed applications so that injected SQL cannot affect unrelated schemas or administrative functions.
  • Prefer query builder utilities that automatically escape identifiers and values and avoid ad-hoc manual SQL concatenation in application or integration code.

How teams detect issues like this

Detection can combine code-centric and behavior-centric approaches:

  • Static analysis: Configure SAST rules to flag SQL strings built via concatenation, especially where variables are interpolated into IN (...) clauses or other filters.
  • Code review: During peer review, look for karma-related queries or helper functions that build SQL strings directly; require parameter binding as a standard.
  • Unit and integration tests: Include negative test cases that inject SQL meta-characters into inputs feeding karma queries and verify they are treated as data, not code.
  • Runtime monitoring: Use database logs, WAF rules, or anomaly detection to identify unusual SQL patterns (e.g., unexpected OR 1=1, stacked statements, or syntax errors from crafted input).
  • Policy enforcement: Adopt coding guidelines or linters that disallow unchecked raw SQL construction in shared framework components and CI gates that fail builds on violations.

Sources

SourceLink
github.comgithub.com/pear/pearweb/security/advisories/GHSA-95mc-p966-c29f

Frequently asked

questions

Yes, if an attacker can control or significantly influence the inputs that PEAR uses in its karma queries, they can exploit the SQL injection remotely through the application interface.

It depends on how the application exposes karma-related operations. In some deployments, only authenticated users can hit the relevant endpoints; in others, public inputs could be mapped to these queries, broadening the attack surface.

Refactor the affected queries to use prepared statements with bound parameters for every dynamic value and avoid string concatenation for IN (...) lists. Combine this with strict validation on any data that might be included in the list.

Standardize on parameterized database access patterns, enforce secure query construction through a shared data access layer, use static analysis and code review checklists to flag raw SQL concatenation, and train developers to treat all external input as untrusted, even when it appears to be a simple identifier list.

Find out what's already
exploitable in your codebase.