Protect Sensitive Data in a Java Project Like Spring Boot

In the digital age, protecting sensitive data has became more critical than ever. Java developers ooften work with Spring Boot, a popular framework for building robust and secure web applications. However, ensuring the security of sensitive data, such as passwords, API keys, and database credentials, requires careful consideration and implementation of best practices. In this blog, we will explore various techniques and examples to safeguard sensitive data in a Java project using Spring Boot.

1. Use Environment Variables

Storing sensitive data directly in your source code is risky, as it can be easily accessed if the codebase is compromised. Instead, consider using environment variables to store this information securely. Spring Boot provides the or application.yml files to configure properties. However, it’s better to use environment variables to store sensitive data in a production environment.


// Instead of storing the API key directly in code:
String apiKey = "YOUR_API_KEY";

// Use an environment variable:
String apiKey = System.getenv("API_KEY");

How to Create Environment Variables:

Open commond line, or terminal and use the export command to create the environment variable. For example, to set an API key:-

export API_KEY=your_api_key_here

2. Encrypting Sensitive Data

Encrypting sensitive data adds an extra layer of protection. Spring Boot allows you to leverage various encryption mechanisms. One common approach is to use the Java Cryptography Extension (JCE) to encrypt and decrypt sensitive information.


import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;

public class EncryptionUtil {

    private static final String ENCRYPTION_ALGORITHM = "AES";
    private static final int KEY_SIZE = 128;

    public static byte[] encrypt(String data, SecretKey key) throws Exception {
        Cipher cipher = Cipher.getInstance(ENCRYPTION_ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, key);
        return cipher.doFinal(data.getBytes());

    public static String decrypt(byte[] encryptedData, SecretKey key) throws Exception {
        Cipher cipher = Cipher.getInstance(ENCRYPTION_ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, key);
        return new String(cipher.doFinal(encryptedData));

    public static SecretKey generateSecretKey() throws Exception {
        KeyGenerator keyGen = KeyGenerator.getInstance(ENCRYPTION_ALGORITHM);
        return keyGen.generateKey();

Prerequisites: to use the encryption and decryption features you need the full-strength JCE installed in your JVM (it’s not there by default). You can download the “Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files” from Oracle, and follow instructions for installation (essentially replace the 2 policy files in the JRE lib/security directory with the ones that you downloaded).

3. Using Spring Security

Spring Security is a powerful framework that provides authentication and authorization functionalities. It can be used to protect sensitive endpoints, enforce access controls, and manage user authentication.


public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    private UserDetailsService userDetailsService;

    protected void configure(HttpSecurity http) throws Exception {

    protected void configure(AuthenticationManagerBuilder auth) throws Exception {

    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();

4. Secure Configuration Files

Spring Boot allows you to externalize configuration properties using YAML or properties files. Ensure that sensitive data is kept in secure locations accessible only by authorized users. For instance, you can use file permissions or secret management tools to control access to sensitive files.


Securing sensitive data in a Java project, especially with SpringBoot, is of utmost importance to protect your application and its users. By employing best practices such as using environment variables, encryption, Spring Security, and securing configuration files, you can significantly reduce the risk of data breaches and unauthorized access.

Remember to follow the least privilege principle and limit access to sensitive data to only those who require it. Always stay up-to-date with the latest security practices and monitor your application for potential vulnerabilities. By prioritizing security from the beginning, you can build a robust and trusted Java project using Spring Boot.