Severity:

HIGH RISK

(7.3)

SQL Injection in delete_activity Endpoint of Society

CVE-2026-1119

Analyzed

Vulnerability type

Category:

SQL Injection

CWE:

CWE-74, CWE-89

Impact:

Unauthorized Database Access and Data Manipulation

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 vulnerability in the /admin/delete_activity.php endpoint of itsourcecode Society Management System 1.0 allows attackers to manipulate the activity_id parameter to interfere with database queries.

When an attacker can send crafted requests to this administrative endpoint, they may access, modify, or delete data in the backend database remotely.

Affected context

This vulnerability occurs in itsourcecode Society Management System 1.0 within the administrative functionality that handles activity deletion via /admin/delete_activity.php.

The issue manifests when the activity_id parameter from an HTTP request is passed directly into an SQL statement without robust input validation, parameterization, or proper escaping.

Environments where this admin endpoint is exposed to the network—and where authentication or access controls are weak or misconfigured—are particularly at risk.

Exploit preconditions

  • Attack surface: HTTP requests targeting /admin/delete_activity.php
  • Required access: Ability to send requests to the admin delete endpoint (through valid credentials, stolen sessions, or misconfigured access control)
  • Trigger point: Submission of a crafted activity_id value in the request (GET or POST, depending on implementation)
  • Why exploitation is possible: The server-side code interpolates the activity_id directly into an SQL query, allowing attacker-controlled data to alter the query structure instead of being treated solely as a value.

Why this happens

The core issue aligns with CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection').

The application constructs SQL queries by concatenating the activity_id parameter directly into the query string, without using prepared statements or safely binding parameters.

This pattern treats user-controlled input as part of the SQL command rather than as data, enabling injection of additional SQL operators, clauses, or statements.

The presence of CWE-74 (Improper Neutralization of Special Elements in Output Used by a Downstream Component) reflects that data is being passed un-sanitized into the database layer, a downstream component, which interprets it as code.

Potential impact

  • Retrieval of sensitive information stored in database tables (e.g., user details, society records)
  • Unauthorized modification or deletion of activities and related records
  • Escalation of privileges by manipulating user or role data in the database
  • Integrity damage to application data, resulting in inconsistent or corrupted records
  • Potential foothold for further attacks, such as creating backdoor accounts or altering configuration data stored in the database

General mitigation guidance

Effective mitigation focuses on removing the ability for user input to influence SQL structure:

  • Use parameterized queries or prepared statements for all database operations involving user-supplied data, including activity_id.
  • Apply strict server-side validation and type enforcement for identifier parameters, ensuring activity_id is treated as an integer or constrained identifier.
  • Centralize database access patterns behind a data access layer that enforces safe query construction by default.
  • Minimize exposure of administrative endpoints through strong authentication, role-based access control, and network-layer restrictions.
  • Adopt a defense-in-depth approach by combining secure coding practices with least-privilege database accounts that can only perform necessary operations.

How teams detect issues like this

Organizations can detect this class of vulnerability using several complementary approaches:

  • Static analysis: Configure SAST tools to flag dynamic SQL construction, string concatenation in queries, and direct use of request parameters in SQL statements in PHP code.
  • Code review: During manual review, look for calls to database APIs where variables derived from $_GET, $_POST, or $_REQUEST are embedded directly into query strings.
  • Runtime testing: Use dynamic application security testing (DAST) or interactive testing to send crafted activity_id values and observe for SQL errors, abnormal responses, or time-based behaviors.
  • Security policy enforcement: Adopt coding standards that mandate prepared statements and input validation for all database interactions, and enforce them via pre-commit hooks or CI pipelines.

Sources

SourceLink
github.comgithub.com/AriazzzZ/CVE/issues/1
itsourcecode.comitsourcecode.com/
vuldb.comvuldb.com/?ctiid.341711
vuldb.comvuldb.com/?id.341711
vuldb.comvuldb.com/?submit.734290

Frequently asked

questions

Exploitability depends on how exposed the /admin/delete_activity.php endpoint is. If it is reachable over the internet and access controls are weak, exploitation can be relatively straightforward, especially given that an exploit has been publicly disclosed.

Not necessarily. If the endpoint is not properly protected or if authentication/session controls can be bypassed or guessed, an attacker may exploit the vulnerability without legitimate admin credentials. However, stronger access control significantly raises the bar for exploitation.

Refactor all queries using activity_id and similar parameters to use prepared statements with bound parameters, combined with strict server-side validation that enforces numeric or whitelisted formats for identifiers. Avoid any direct string concatenation of user input into SQL queries.

Establish development standards that require parameterized queries by default, regular security-focused code reviews, automated scanning for unsafe query patterns, and thorough validation of all externally supplied input before it reaches the data access layer. Consistently applying these patterns reduces the likelihood of SQL injection vulnerabilities across the codebase.

Find out what's already
exploitable in your codebase.