· Alex · security  · 11 min read

How to Prevent SQL Injection in Java

From input validation, to using parametrized queries, prepared statements, ORMs and more

From input validation, to using parametrized queries, prepared statements, ORMs and more

How to Prevent SQL Injection in Java

Definition and examples of SQL injection

SQL injection is a technique used by hackers to insert malicious SQL code into an application’s query. This allows them to gain unauthorized access to, modify, or even delete data from a database. Imagine a simple login form where users input their username and password. A typical SQL query for checking the credentials might look like this:

SELECT * FROM users WHERE username='USERNAME' AND password='PASSWORD';

Now, let’s say a hacker enters the following as the username: admin' --. The SQL query becomes:

SELECT \ FROM users WHERE username='admin' --' AND password='PASSWORD';

Notice the two dashes (--)? They’re used to comment out the rest of the SQL query, so the password check is skipped entirely. Boom! The hacker gains unauthorized access to the admin account.

For more information, see my blog post on blind SQL injections.

Consequences of successful SQL injection attacks

SQL injection attacks can have disastrous consequences. If an attacker successfully exploits a vulnerability, they might:

  1. Access sensitive data: The attacker can view personal information like usernames, passwords, email addresses, and more.
  2. Modify data: They can change or delete records, potentially causing irreversible damage to your application.
  3. Bypass authentication: As shown in our example, attackers can gain unauthorized access to admin accounts or other restricted areas.
  4. Execute administrative operations: Attackers could create new users with elevated privileges, drop tables, or even shut down the database server.

Input Validation and Sanitization

Importance of validating and sanitizing user inputs

The first line of defense in preventing SQL injection is validating and sanitizing user inputs. Validating user input ensures that the data entered into your application meets specific criteria, like being the correct data type or within a certain range. Sanitizing, on the other hand, involves cleaning the input to ensure any potentially harmful content is neutralized.

Java libraries for input sanitization

Why reinvent the wheel when there are fantastic Java libraries out there to help you with input sanitization? Here are a couple of popular options to consider:

  1. OWASP Java Encoder: This library, provided by the Open Web Application Security Project (OWASP), focuses on encoding potentially harmful characters to prevent security vulnerabilities like SQL injection and cross-site scripting (XSS). Check it out here: https://owasp.org/www-project-java-encoder/
  2. Apache Commons Validator: This library offers a variety of validation functions, including email validation, credit card number validation, and URL validation.

Parameterized Queries and Prepared Statements

The concept of parameterized queries

Think of parameterized queries as mad libs for SQL. Instead of mixing user input directly into your SQL query, you create a template with placeholders for the values you want to insert. These placeholders are then replaced with actual values when the query is executed. This keeps user input separate from the SQL query itself, ensuring that malicious input won’t sneak its way into your query.

Benefits of using prepared statements

Prepared statements come with some additional benefits:

  1. Performance: Prepared statements can be compiled and optimized by the database server, which can lead to improved performance, especially when executing the same query multiple times.
  2. Readability: Using placeholders makes your SQL queries easier to read and maintain.

Creating prepared statements in Java using JDBC

Java makes it super easy to create prepared statements using the Java Database Connectivity (JDBC) API. Here’s a step-by-step guide:

  1. First, make sure you’ve established a connection to your database using JDBC.
  2. Next, create a prepared statement object by calling the prepareStatement() method on your connection object, passing in your SQL query with placeholders. For example:
String sql = "INSERT INTO users (username, email) VALUES (?, ?)"; PreparedStatement preparedStatement = connection.prepareStatement(sql); 

Notice the question marks? Those are your placeholders!

Using placeholders and binding values

Now that you have your prepared statement with placeholders, it’s time to bind actual values to those placeholders. You can do this using the various setX() methods provided by the PreparedStatement class, where X is the data type you want to set (e.g., setString, setInt, setDate).

For example:

preparedStatement.setString(1, "user"); 
preparedStatement.setString(2, "[email protected]"); 

The first parameter in the setX() methods is the index of the placeholder you want to bind the value to (starting from 1), and the second parameter is the actual value.

Executing prepared statements

Finally, with your prepared statement all set up and your values bound, it’s time to execute the statement. You can do this using one of the executeX() methods provided by the PreparedStatement class, depending on the type of SQL query you’re executing. For example:

  1. For SELECT queries, use executeQuery() to return a ResultSet object:
ResultSet resultSet = preparedStatement.executeQuery();
  1. For INSERT, UPDATE, or DELETE queries, use executeUpdate() to return the number of affected rows:
int affectedRows = preparedStatement.executeUpdate();
  1. If you’re not sure what type of query you’re executing, you can use the more general execute() method:
boolean isResultSet = preparedStatement.execute(); 

By using parameterized queries and prepared statements, you’re taking a big step towards making your Java application more secure against SQL injection attacks.

Stored Procedures

Definition and advantages of stored procedures

Think of stored procedures as pre-cooked SQL queries that you can call upon whenever you need them. They’re essentially SQL scripts stored in the database itself and can be executed by calling their names. Stored procedures come with some nifty advantages:

  1. Security: Since they’re predefined and don’t involve direct SQL query manipulation, stored procedures can help reduce the risk of SQL injection attacks.
  2. Performance: Because they’re stored in the database, they can be pre-compiled and optimized for faster execution.
  3. Maintainability: Having your SQL queries in one central location makes it easier to manage and update your code.

Implementing stored procedures in a database

Creating a stored procedure varies depending on the database management system (DBMS) you’re using. But, in general, you’ll define the procedure using the DBMS’s SQL dialect and store it in the database. For example, in MySQL, you can create a stored procedure like this:

CREATE PROCEDURE GetUserByUsername(IN username VARCHAR(50)) 
   SELECT * FROM users WHERE username = username; 

This stored procedure, named GetUserByUsername, accepts a username parameter and returns the user record with the matching username.

Calling stored procedures from Java

To call a stored procedure from your Java application, you’ll use the JDBC API, much like you would with prepared statements. Here’s how:

  1. First, establish a connection to your database using JDBC.
  2. Create a CallableStatement object by calling the prepareCall() method on your connection object, passing in your stored procedure call syntax. For example:
String sql = "{CALL GetUserByUsername(?)}"; 
CallableStatement callableStatement = connection.prepareCall(sql);
  1. Bind any input parameters using the setX() methods, just like you would with prepared statements:
callableStatement.setString(1, "user");
  1. Execute the stored procedure using the appropriate executeX() method, depending on the type of query:
ResultSet resultSet = callableStatement.executeQuery();

And that’s it! You’ve now successfully called a stored procedure from your Java application.

Security considerations when using stored procedures

While stored procedures can be a great way to prevent SQL injection attacks, there are still some security considerations to keep in mind:

  1. Don’t mix user input directly into your stored procedure call syntax. Instead, always use parameterized calls, as shown in the example above.
  2. Avoid using dynamic SQL within your stored procedures, as this can reintroduce the risk of SQL injection.

Using Object-Relational Mapping (ORM) Frameworks

About ORM frameworks

Let’s dive into another approach that can help prevent SQL injection attacks in your application: using Object-Relational Mapping (ORM) frameworks. An ORM framework maps your database tables to classes in your programming language, allowing you to interact with your database using objects and methods instead of writing raw SQL queries. Some popular ORM frameworks for Java include:

  1. Hibernate
  2. Java Persistence API (JPA) with implementations like EclipseLink or Apache OpenJPA
  3. jOOQ

By abstracting away the SQL layer, ORM frameworks can help protect your application from SQL injection attacks while also providing other benefits, such as improved code maintainability and reduced development time.

How ORMs prevent SQL injection

ORM frameworks typically generate SQL queries internally based on the method calls you make in your code, and they often use prepared statements or parameterized queries under the hood. This means that user input is automatically separated from the SQL query, reducing the risk of SQL injection. For example, using Hibernate, you might execute a query like this:

Session session = sessionFactory.openSession(); 
Transaction tx = session.beginTransaction(); 
CriteriaBuilder builder = session.getCriteriaBuilder(); 
CriteriaQuery<User> query = builder.createQuery(User.class); 
Root<User> root = query.from(User.class); 
query.select(root).where(builder.equal(root.get("username"), "user"));
List<User> users = session.createQuery(query).getResultList();

In this example, the query is generated using the Hibernate API, and the user input (in this case, the username) is automatically parameterized, making it not vulnerable to SQL injection.

Additional security considerations when using ORMs

While ORM frameworks can offer a significant layer of protection against SQL injection attacks, it’s important to remember that they’re not a magic bullet. There are still security best practices to follow when using an ORM:

  1. Validate and sanitize user input: Even when using an ORM, it’s essential to validate and sanitize user input to prevent other types of security vulnerabilities.
  2. Use parameterized queries: While most ORMs use parameterized queries by default, there might be cases where you need to write custom SQL queries within your ORM. Always use parameterized queries in these situations.

Regularly Monitoring and Auditing

Importance of monitoring and auditing database activity

Even with the best defenses in place, it’s essential to keep an eye on your application and database to detect any potential breaches or vulnerabilities. That’s where monitoring and auditing come into play. Regularly monitoring and auditing your database activity helps you identify suspicious behavior, detect security breaches, and pinpoint any weaknesses in your system. This proactive approach allows you to address potential issues before they escalate and cause significant damage.

Database logs and their role in security

Database logs are like the black box of your database – they record various types of information, including user connections, queries executed, and any errors or warnings that occur. By regularly reviewing your database logs, you can spot unusual patterns or unauthorized access attempts, which may indicate a security breach. To get the most out of your logs, make sure they’re configured to record relevant security events, such as failed login attempts, changes to user permissions, and any modifications to your database schema. Additionally, remember to store your logs securely and rotate them regularly to prevent log tampering and ensure optimal system performance.

Reviewing and updating security measures

Last but not least, don’t forget to periodically review and update your security measures. Some best practices for maintaining a strong security posture include:

  • Regularly applying security patches and updates for your software, including your Java application, database, and operating system.
  • Periodically reviewing and updating your access control policies to ensure they adhere to the least privilege principle.
  • Staying informed about the latest security trends and vulnerabilities in your technology stack.

Educating Developers and Continuous Learning

The role of education in preventing SQL injection

As you’ve probably realized by now, one of the most effective ways to prevent SQL injection attacks is by educating yourself and your fellow developers. After all, understanding the risks, knowing how to write secure code, and being aware of the latest security best practices are essential ingredients in building a robust defense against SQL injection. By fostering a culture of continuous learning and security awareness within your team, you can reduce the likelihood of introducing vulnerabilities in your Java applications and improve your overall security posture.

Staying updated on security best practices

Security is an ever-evolving field, with new threats and vulnerabilities constantly emerging. As a Java developer, it’s crucial to stay updated on the latest security best practices and trends. This can help you identify potential risks and adapt your coding practices to stay one step ahead of the bad guys. Some ways to stay informed include:

  • Following security blogs and forums
  • Subscribing to newsletters from security organizations and vendors
  • Attending security conferences and workshops

Resources for learning about SQL injection prevention

Luckily, there’s no shortage of resources available to help you learn about SQL injection prevention. Some excellent resources to get you started include:

  1. OWASP Top Ten Project: The Open Web Application Security Project (OWASP) regularly publishes a list of the top ten most critical web application security risks, which includes SQL injection. Their website offers detailed explanations, prevention techniques, and best practices.
  2. Online tutorials and courses: Many websites offer tutorials and courses on secure coding practices, including how to prevent SQL injection in Java applications.
  3. Books and articles: There are numerous books and articles available that cover the topic of SQL injection prevention and other security best practices for Java developers.


Well, folks, we’ve covered quite a bit of ground on our journey to preventing SQL injection attacks in Java applications! Let’s take a moment to recap the main points we’ve discussed: we’ve discussed about understanding SQL injection, how to mitigate them using input validation and sanitization, parameterized queries, prepared statements, and stored procedures. Finally, we talked about education and continuous learning. As developers, it’s our responsibility to proactively protect our applications and the sensitive data they handle.


About the Author:


Application Security Engineer and Red-Teamer. Over 15 years of experience in Application Security, Software Engineering and Offensive Security. OSCE3 & OSCP Certified. CTF nerd.

Back to Blog

Related Posts

View All Posts »