How To Prevent SQL Injection in PHP

Published May 20, 2024

SQL injection is a big security problem that can let attackers change database queries and get access to private data they shouldn't have. In PHP applications, SQL injection attacks happen when user input is not checked or cleaned before being used in SQL queries. This article looks at the different kinds of SQL injection attacks, shows examples of PHP code that is open to attack, and talks about the best ways to stop SQL injection problems in your applications.

Understanding SQL Injection Attacks in PHP

What is SQL Injection?

SQL injection is a technique used by attackers to inject malicious SQL code into a vulnerable PHP application. It happens when user input is not properly validated or sanitized before being used in an SQL query. Attackers exploit inadequate input validation and dynamic SQL queries to manipulate the application's behavior and gain unauthorized access to the database. By crafting special input values, attackers can modify the structure of the SQL query, bypass authentication, retrieve sensitive information, or even execute arbitrary SQL commands on the database server.

Here's an example of a vulnerable PHP code snippet that allows SQL injection:

$username = $_POST['username'];
$password = $_POST['password'];

$query = "SELECT * FROM users WHERE username='$username' AND password='$password'";
$result = mysqli_query($connection, $query);

In this code, the user-supplied $username and $password values are directly concatenated into the SQL query without any validation or sanitization. An attacker can exploit this vulnerability by entering malicious input like:

username: admin' --
password: anyvalue

The resulting SQL query would be:

SELECT * FROM users WHERE username='admin' -- AND password='anyvalue'

The -- comment syntax nullifies the password check, allowing the attacker to bypass authentication and gain unauthorized access.

Common Types of SQL Injection Attacks

Union-based SQL Injection

In this type of attack, attackers use the UNION operator to combine the results of multiple SELECT statements and extract sensitive information. By appending a malicious SELECT statement to the original query, attackers can retrieve data from different tables or columns that were not intended to be accessible. This technique relies on the application returning the result of the injected query to the attacker.

Example of a union-based SQL injection:

Original query:

SELECT name, description FROM products WHERE id = $id

Injected query:

SELECT name, description FROM products WHERE id = 1 UNION SELECT username, password FROM users

The injected query combines the original query with an additional SELECT statement that retrieves sensitive user credentials from the users table.

Blind SQL Injection

Blind SQL injection occurs when the application does not directly return the results of the injected query to the attacker. Instead, attackers send crafted queries and observe the application's response to infer the structure and contents of the database. They do this by making the application behave differently based on the outcome of the injected condition. By carefully constructing the queries and analyzing the application's response time, error messages, or other behavioral changes, attackers can extract sensitive information one bit at a time.

Example of a blind SQL injection:

Original query:

SELECT * FROM users WHERE id = $id

Injected query:

SELECT * FROM users WHERE id = 1 AND SUBSTRING(password, 1, 1) = 'a'

In this case, the attacker injects a condition that checks if the first character of the password is 'a'. By observing the application's response (e.g., a delay or an error), the attacker can determine if the condition is true or false and gradually guess the password character by character.

Error-based SQL Injection

In this technique, attackers intentionally trigger SQL errors to gather information about the database and its schema. They do this by inserting malformed SQL statements or special characters that cause the database to generate error messages. These error messages often contain valuable information such as table names, column names, or even portions of sensitive data. Attackers can use this information to refine their attacks and target specific parts of the database.

Example of an error-based SQL injection:

Injected query:

SELECT * FROM users WHERE id = 1 AND (SELECT 1 FROM (SELECT COUNT(*), CONCAT((SELECT (SELECT CONCAT(username,':',password)) FROM users LIMIT 0,1), 0x3a, FLOOR(RAND(0)*2)) x FROM information_schema.tables GROUP BY x) a)

This complex injected query attempts to extract the username and password from the users table by triggering an error that includes the sensitive information in the error message.

Preventing SQL Injection Attacks

To prevent SQL injection attacks in PHP applications, follow these best practices:

Practice Description
Parameterized Queries Use prepared statements with parameterized queries to separate user input from the SQL query structure.
Input Validation Validate and sanitize user input before using it in SQL queries. Reject or sanitize any special characters or malicious input.
Least Privilege Configure the database user account to have minimal privileges required for the application's functionality.
Escaping Special Characters If parameterized queries are not possible, properly escape special characters in user input using PHP's mysqli_real_escape_string() or PDO's quote() function.
Stored Procedures Use stored procedures to encapsulate database operations and limit the access to the underlying tables.
Prepared Statements Use prepared statements to precompile SQL queries and separate user input from the query structure. Prepared statements treat user input as data, not as part of the SQL command.

Here's a diagram illustrating the flow of a SQL injection attack:

graph TD A[Attacker] --> B[Crafts malicious input] B --> C[Sends malicious input to the application] C --> D[Application receives the input] D --> E{Input properly validated/sanitized?} E -->|No| F[SQL query concatenated with malicious input] F --> G[Database executes the injected query] G --> H[Attacker gains unauthorized access or retrieves sensitive data] E -->|Yes| I[SQL query executed safely] I --> J[Application functions as intended]

Preventing SQL Injection in PHP with Prepared Statements

Prepared Statements

Prepared statements run SQL queries by separating the SQL logic from user input. They defend against SQL injection attacks. Instead of putting user input into the SQL query, prepared statements use placeholders (e.g., ? or named parameters like :username) for the input values. These placeholders are later bound to the actual values before running the query. By separating the SQL structure from the user input, prepared statements treat the input as data and not as part of the SQL command, preventing malicious SQL code injection.

PDO (PHP Data Objects) for Prepared Statements

PDO (PHP Data Objects) is an extension in PHP that provides a consistent and secure way to interact with different databases. It supports prepared statements and parameterized queries, making it a good choice for preventing SQL injection vulnerabilities.

PDO provides methods to prepare, bind, and run SQL statements securely. It handles the differences between database vendors, allowing you to write portable and maintainable code. PDO also offers better performance than traditional MySQL functions, as it can reuse the same prepared statement multiple times with different parameter values.

Guide to Using Prepared Statements with PDO

Here's a guide on how to use prepared statements with PDO to prevent SQL injection in PHP:

  1. Connect to the database with PDO:

    $dsn = 'mysql:host=localhost;dbname=mydatabase';
    $username = 'your_username';
    $password = 'your_password';
    try {
       $pdo = new PDO($dsn, $username, $password);
       $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
    } catch (PDOException $e) {
       die('Connection failed: ' . $e->getMessage());
  2. Prepare the SQL query with placeholders for user input:

    $stmt = $pdo->prepare("SELECT * FROM users WHERE username = :username");

    In this example, :username is a named parameter that serves as a placeholder for the user-supplied username value.

  3. Bind the user input to the placeholders:

    $username = $_POST['username'];
    $stmt->bindParam(':username', $username);

    The bindParam() method binds the user input to the named parameter in the prepared statement. It treats the input as data and not as part of the SQL command.

  4. Run the prepared statement:


    The execute() method runs the prepared statement with the bound parameter values.

  5. Fetch and process the results:

    $user = $stmt->fetch(PDO::FETCH_ASSOC);

    The fetch() method retrieves the result of the executed statement. You can specify the fetch style, such as PDO::FETCH_ASSOC, to return an associative array.

Example: User Login

Let's consider an example of a user login system where we need to get user information based on the provided username and password. Here's how you can use prepared statements with PDO to prevent SQL injection:

// Get the user input from the login form
$username = $_POST['username'];
$password = $_POST['password'];

// Prepare the SQL query with placeholders
$stmt = $pdo->prepare("SELECT * FROM users WHERE username = :username AND password = :password");

// Bind the user input to the placeholders
$stmt->bindParam(':username', $username);
$stmt->bindParam(':password', $password);

// Run the prepared statement

// Fetch the user record
$user = $stmt->fetch(PDO::FETCH_ASSOC);

// Check if the user exists and the password is correct
if ($user) {
    // User authenticated successfully
    // Perform actions (e.g., set session, redirect)
} else {
    // Invalid username or password
    // Display an error message

In this example, the user-provided username and password are bound to the placeholders in the prepared statement. The SQL query is executed securely, preventing potential SQL injection attempts.

Benefits of Prepared Statements

  • Separates SQL logic from user input, preventing SQL injection attacks
  • Improves code readability and maintainability
  • Allows reuse of the same prepared statement with different parameter values
  • Provides better performance than traditional MySQL functions

Best Practices

  • Always use prepared statements for SQL queries with user input
  • Validate and sanitize user input before using it in SQL queries
  • Use named parameters for readability and maintainability
  • Implement secure database configuration and least privilege access control
  • Keep your PHP and database software updated with the latest security patches

Additional Measures for Preventing SQL Injection in PHP

Input Validation Techniques

Besides using prepared statements, you should validate and clean user input before using it in SQL queries. Input validation prevents SQL injection attacks by checking that the data entered by users matches the expected format and only has allowed characters.

Whitelisting is a good technique, where you define a set of allowed characters or patterns and reject any input that doesn't match those rules. For example, if you expect a user to enter a numeric ID, you can validate the input using regular expressions to check that it only contains digits.

Here's an example of validating a numeric ID using PHP:

$id = $_POST['id'];

// Validate that the ID contains only digits
if (!preg_match('/^\d+$/', $id)) {
    // Invalid input, handle the error
    die("Invalid ID format");

// Use the validated ID in the SQL query
$stmt = $pdo->prepare("SELECT * FROM users WHERE id = ?");

In this example, the preg_match() function checks if the $id variable contains only digits. If the validation fails, an error is thrown, stopping the invalid input from being used in the SQL query.

You should also properly escape special characters and use the right encoding methods. Special characters like single quotes, double quotes, and backslashes can be used to manipulate SQL queries if not handled correctly. By escaping these characters or using appropriate encoding functions, you can stop them from being interpreted as part of the SQL syntax.

PHP has functions like mysqli_real_escape_string() or PDO::quote() to escape special characters in user input. However, it is generally better to use prepared statements with parameterized queries instead of manual escaping, as it is a more reliable and secure approach.

Here are some examples of common input validation techniques:

Technique Description Example
Whitelisting Allow only specific characters or patterns Allow only alphanumeric characters: /^[a-zA-Z0-9]+$/
Length Validation Check the length of the input Ensure username is between 4 and 20 characters: /^.{4,20}$/
Type Validation Validate the input type (e.g., integer, email) Validate an email address: /^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z]{2,}$/i
Range Validation Check if the input falls within a specified range Ensure age is between 18 and 120: /^(1[89]|[2-9]\d|1[01]\d|120)$/

Stored Procedures and Parameterized Queries

Stored procedures are precompiled SQL statements that are stored in the database and can be called from the application code. They add an extra layer of security by encapsulating complex SQL logic and limiting access to the underlying tables.

When using stored procedures, you can define parameters that accept user input, similar to prepared statements. By passing user input as parameters to stored procedures, you can prevent SQL injection attacks since the input is treated as data and not as part of the SQL command.

Here's an example of a stored procedure that retrieves user information based on a provided username:

    @Username VARCHAR(50)
    SELECT * FROM users WHERE username = @Username

In this example, the stored procedure GetUserByUsername accepts a parameter @Username and uses it in the SQL query to retrieve user information. The parameter is treated as data, preventing SQL injection.

To call the stored procedure from PHP, you can use PDO or MySQLi:

$username = $_POST['username'];

$stmt = $pdo->prepare("CALL GetUserByUsername(?)");
$user = $stmt->fetch(PDO::FETCH_ASSOC);

By using stored procedures with parameterized queries, you can centralize the database access logic, improve performance, and enhance the security of your PHP application.

Least Privilege Principle and Database User Roles

The principle of least privilege means that users and applications should have only the minimum permissions needed to do their tasks. Applying this principle to database user roles and permissions is an important step in preventing SQL injection and reducing the impact of potential attacks.

When setting up the database user for your PHP application, limit its access rights to the minimum required for the application's functionality. This means giving the user only the permissions needed to perform specific tasks, such as SELECT, INSERT, UPDATE, or DELETE, on the relevant tables.

By restricting the database user's privileges, you can reduce the potential damage an attacker can cause if they manage to exploit an SQL injection vulnerability. For example, if the application only needs read access to certain tables, the database user should be granted SELECT privilege on those tables only, preventing any unauthorized changes or deletions.