/

CVE-2026-13550

Severity:

HIGH RISK

(7.3)

SQL Injection (CWE-89) in Baptism Management System

CVE-2026-13550

Deferred

Vulnerability type

Category:

SQL Injection

CWE:

CWE-74, CWE-89

Impact:

Data Exposure and Manipulation via SQL Injection

Severity:

HIGH RISK

(7.3)

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 flaw exists in the itsourcecode Baptism Information Management System 1.0, where the ID parameter in /delbaptism.php is processed unsafely.

An attacker can remotely manipulate database queries, potentially reading or altering data and impacting application integrity when crafted input is passed into the vulnerable parameter.

Affected context

The vulnerability occurs in the Baptism Information Management System 1.0 within the /delbaptism.php endpoint, which appears to handle deletion or retrieval of baptism records using an ID parameter.

The issue is present when user-controlled ID values are directly concatenated into SQL statements without proper parameterization or strict validation.

This typically manifests in PHP/MySQL style code where request parameters are trusted and interpolated into query strings instead of using prepared statements.

Exploit preconditions

  • Attack surface: HTTP(S) interface exposing /delbaptism.php
  • Required access: Ability to send crafted requests to the affected endpoint (often anonymous or low-privileged web access)
  • Trigger point: Supplying malicious content in the ID parameter (query string, POST body, or form submission) that is later incorporated into an SQL query
  • Why exploitation is possible: The application builds SQL queries using string concatenation or interpolation of the ID parameter without parameterized queries or adequate input sanitization, enabling attacker-controlled fragments of SQL logic to be executed by the database engine

Why this happens

The root cause aligns with CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection') and is related to CWE-74: Improper Neutralization of Special Elements in Output Used by a Downstream Component.

The application likely takes user input from the ID parameter and directly embeds it into an SQL statement such as a DELETE or SELECT query, using string concatenation or insecure templating.

By failing to treat the ID value strictly as data (for example, via bound parameters), the code allows user input to alter the structure of the SQL command, enabling injection of additional clauses or statements.

Potential impact

  • An attacker may read sensitive baptism records or related personal information beyond their authorized scope.
  • An attacker could modify or delete baptism entries and associated data, affecting integrity of church or organizational records.
  • An attacker may create new unauthorized records to falsify or manipulate official registers.
  • An attacker could attempt database-level attacks such as schema enumeration or extraction of authentication-related data, depending on database configuration and privileges.
  • An attacker may chain this issue with other weaknesses to escalate impact, including potential access to underlying host data if the DB user is highly privileged.

General mitigation guidance

Effective mitigation focuses on ensuring user input cannot change the structure of SQL statements and reducing trust in web-supplied parameters:

  • Use parameterized queries or prepared statements for all database operations, particularly where identifiers like ID are involved.
  • Enforce strict server-side validation and type checking on the ID parameter (e.g., accepting only numeric values where appropriate).
  • Centralize database-access patterns behind a data access layer that forbids dynamic query construction using raw user input.
  • Apply least-privilege to database accounts so that application credentials have only the minimal permissions needed (e.g., limited to specific tables and operations).
  • Consider using an input-validation and encoding strategy aligned with context (e.g., rejecting unexpected characters rather than trying to sanitize them).
  • Implement secure-by-default coding standards and training, discouraging ad hoc query concatenation in PHP or other languages used.

How teams detect issues like this

Detection typically involves both code-centric and behavior-centric techniques:

  • Static analysis: Configure security linters or SAST tools to flag dynamic SQL construction, string concatenation around query keywords, and use of unsanitized request variables in SQL functions.
  • Code review: Look for PHP code that uses $_GET, $_POST, or $_REQUEST['ID'] directly in query strings; verify that all queries use prepared statements and bound parameters.
  • Logging and monitoring: Monitor database logs and application logs for anomalous query patterns, such as unexpected OR 1=1, stacked queries, or sudden spikes in failed queries, which may indicate probing for SQL injection.
  • Security testing: Use automated DAST tools or manual penetration testing with safe test payloads to identify endpoints where user input is reflected in SQL error messages or response anomalies.

Sources

SourceLink
github.comgithub.com/Hh-176/CVE/issues/1
itsourcecode.comitsourcecode.com/
vuldb.comvuldb.com/cve/CVE-2026-13550
vuldb.comvuldb.com/submit/843567
vuldb.comvuldb.com/vuln/374558
vuldb.comvuldb.com/vuln/374558/cti

Frequently asked

questions

Yes. As described, the flaw is reachable via HTTP requests to /delbaptism.php, and proof-of-concept exploit code is publicly available, making remote exploitation feasible where the application is exposed.

Typically, only network access to the web application is required. If /delbaptism.php is reachable without authentication or with weak access controls, even low-privileged or unauthenticated users may exploit it.

Refactor all database interactions in the affected code path to use parameterized queries or prepared statements, combined with strict server-side validation of the ID parameter, ensuring it is treated purely as data and not allowed to alter the SQL structure.

Adopt a development standard that forbids dynamic SQL string concatenation with user input, enforce prepared statements through a shared data access layer, integrate SAST/DAST into the CI/CD pipeline, and regularly train developers on secure query construction and input-handling patterns.

Find out what's already
exploitable in your codebase.