Encrypt Passwords in a Spring Boot Using Jasypt

How to Encrypt Passwords in a Spring Boot Using Jasypt

In today's digital landscape, securing sensitive information such as passwords is paramount. In Java Spring Boot applications, one of the most effective ways to achieve this is by using Jasypt (Java Simplified Encryption). Jasypt provides a simple way to encrypt and decrypt sensitive data, making it an excellent choice for password management. 

How to Encrypt Passwords in a Spring Boot Using Jasypt

In this blog post, we will explore how to integrate Jasypt into a Spring Boot project to encrypt passwords securely. We will cover the following topics:

1. What is Jasypt?
2. Setting Up Jasypt in a Spring Boot Project
3. Encrypting and Decrypting Passwords
4. Using Encrypted Passwords in Spring Boot
5. Conclusion

What is Jasypt?

Jasypt is a Java library that allows developers to add basic encryption capabilities to their applications. It provides a simple API for encryption and decryption, making it easy to secure sensitive data without requiring extensive knowledge of cryptography.

Setting Up Jasypt in a Spring Boot Project

To get started, we need to add the Jasypt dependency to our Spring Boot project. If you are using Maven, add the following dependency to your pom.xml:

<dependency>
    <groupId>com.github.ulisesbocchio</groupId>
    <artifactId>jasypt-spring-boot-starter</artifactId>
    <version>3.0.4</version>
</dependency>

If you are using Gradle, add the following line to your build.gradle:

implementation 'com.github.ulisesbocchio:jasypt-spring-boot-starter:3.0.4'

Text-Based Diagram: Project Structure

MySpringBootApp
│
├── src
│   ├── main
│   │   ├── java
│   │   │   └── com
│   │   │       └── example
│   │   │           └── myapp
│   │   │               ├── MySpringBootApp.java
│   │   │               ├── config
│   │   │               │   └── JasyptConfig.java
│   │   │               └── service
│   │   │                   └── UserService.java
│   │   └── resources
│   │       └── application.properties
│   └── test
│       └── java
└── pom.xml

Encrypting and Decrypting Passwords

Step 1: Generate an Encryption Key

Before we can encrypt passwords, we need to generate a secret key. You can use the Jasypt command-line tool or any online tool to generate a key. For this example, let's assume our key is mySecretKey.

Step 2: Encrypt a Password

You can encrypt a password using the Jasypt CLI tool or programmatically. Here’s how to do it programmatically:

import org.jasypt.util.text.AES256TextEncryptor;

public class PasswordEncryption {
    public static void main(String[] args) {
        String password = "myPassword";
        String secretKey = "mySecretKey";

        AES256TextEncryptor textEncryptor = new AES256TextEncryptor();
        textEncryptor.setPassword(secretKey);
        String encryptedPassword = textEncryptor.encrypt(password);

        System.out.println("Encrypted Password: " + encryptedPassword);
    }
}

Step 3: Store the Encrypted Password

Once you have the encrypted password, you can store it in your database or configuration file.

Using Encrypted Passwords in Spring Boot

Step 1: Configure Jasypt in application.properties

Add the following properties to your application.properties file:

jasypt.encryptor.password=mySecretKey

Step 2: Create a Jasypt Configuration Class

Create a configuration class to set up Jasypt:

import org.jasypt.spring31.properties.EncryptableProperties;
import org.jasypt.spring31.properties.PropertySourcesPlaceholderConfigurer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class JasyptConfig {

    @Bean
    public static PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer() {
        return new PropertySourcesPlaceholderConfigurer();
    }
}

Step 3: Use Encrypted Passwords in Your Service

Now, you can use the encrypted password in your service class:

import org.jasypt.util.text.AES256TextEncryptor;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    @Value("${encrypted.password}")
    private String encryptedPassword;

    public void printDecryptedPassword() {
        AES256TextEncryptor textEncryptor = new AES256TextEncryptor();
        textEncryptor.setPassword("mySecretKey");
        String decryptedPassword = textEncryptor.decrypt(encryptedPassword);
        System.out.println("Decrypted Password: " + decryptedPassword);
    }
}

Text-Based Diagram: Password Encryption Flow

User  Input
   │
   ▼
[Password]
   │
   ▼
[Encrypt with Jasypt]
   │
   ▼
[Encrypted Password]
   │
   ▼
[Store in Database]

Conclusion

In this blog post, we explored how to securely encrypt passwords in a Spring Boot application using Jasypt. By following the steps outlined above, you can ensure that sensitive information such as passwords is stored securely, reducing the risk of unauthorized access. Implementing encryption is a crucial step in safeguarding user data and maintaining the integrity of your application.