Spring Security Remember Me

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Distributed systems often come with complex challenges such as service-to-service communication, state management, asynchronous messaging, security, and more.

Dapr (Distributed Application Runtime) provides a set of APIs and building blocks to address these challenges, abstracting away infrastructure so we can focus on business logic.

In this tutorial, we'll focus on Dapr's pub/sub API for message brokering. Using its Spring Boot integration, we'll simplify the creation of a loosely coupled, portable, and easily testable pub/sub messaging system:

>> Flexible Pub/Sub Messaging With Spring Boot and Dapr

1. Overview

This tutorial will show how to enable and configure Remember Me functionality in a web application with Spring Security. Setting up the MVC application with security and a simple form login has already been discussed.

The mechanism will be able to identify the user across multiple sessions – so the first thing to understand is that Remember Me only kicks in after the session times out. By default, this happens after 30 minutes of inactivity, but timeout can be configured in the web.xml.

Note: this tutorial focuses on the standard cookie-based approach. For the persistent approach, have a look at the Spring Security – Persistent Remember Me guide.

2. The Security Configuration

Let’s see how to set up the security configuration using Java:

@Configuration
@EnableWebSecurity
public class SecSecurityConfig {

    @Bean
    public AuthenticationManager authenticationManager(HttpSecurity http) throws Exception {
        return http.getSharedObject(AuthenticationManagerBuilder.class)
            .build();
    }

    @Bean
    public InMemoryUserDetailsManager userDetailsService() {
        UserDetails user = User.withUsername("user1")
            .password("{noop}user1Pass")
            .authorities("ROLE_USER")
            .build();
        UserDetails admin = User.withUsername("admin1")
            .password("{noop}admin1Pass")
            .authorities("ROLE_ADMIN")
            .build();
        return new InMemoryUserDetailsManager(user, admin);
    }

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http.authorizeHttpRequests(auth -> auth.requestMatchers("/anonymous*")
            .anonymous()
            .requestMatchers("/login*")
            .permitAll()
            .anyRequest()
            .authenticated())
            .formLogin(formLogin -> formLogin.loginPage("/login.html")
                .loginProcessingUrl("/login")
                .failureUrl("/login.html?error=true"))
            .rememberMe(rememberMe -> rememberMe.key("uniqueAndSecret"))
            .logout(logout -> logout.deleteCookies("JSESSIONID"));
        return http.build();
    }

As you can see, the basic configuration using the rememberMe() method is extremely simple while remaining very flexible through additional options. The key is important here – it is a private value secret for the entire application and it will be used when generating the contents of the token.

Additionally, the time the token is valid can be configured from the default of 2 weeks to – for example – one day using tokenValiditySeconds():

rememberMe(rememberMe -> rememberMe.key("uniqueAndSecret").tokenValiditySeconds(86400))

We can also have a look at the equivalent XML configuration:

<http use-expressions="true">
    <intercept-url pattern="/anonymous*" access="isAnonymous()" />
    <intercept-url pattern="/login*" access="permitAll" />
    <intercept-url pattern="/**" access="isAuthenticated()" />

    <form-login login-page='/login.html' 
      authentication-failure-url="/login.html?error=true" />
    <logout delete-cookies="JSESSIONID" />

    <remember-me key="uniqueAndSecret"/>
</http>

<authentication-manager id="authenticationManager">
    <authentication-provider>
        <user-service>
            <user name="user1" password="{noop}user1Pass" authorities="ROLE_USER" />
            <user name="admin1" password="{noop}admin1Pass" authorities="ROLE_ADMIN" />
        </user-service>
    </authentication-provider>
</authentication-manager>

The login form is similar to the one we used for form login:

<html>
<head></head>

<body>
    <h1>Login</h1>

    <form name='f' action="login" method='POST'>
        <table>
            <tr>
                <td>User:</td>
                <td><input type='text' name='username' value=''></td>
            </tr>
            <tr>
                <td>Password:</td>
                <td><input type='password' name='password' /></td>
            </tr>
            <tr>
                <td>Remember Me:</td>
                <td><input type="checkbox" name="remember-me" /></td>
            </tr>
            <tr>
                <td><input name="submit" type="submit" value="submit" /></td>
            </tr>
        </table>
    </form>

</body>
</html>

Notice the newly added checkbox input – mapping to remember-me. This added input is enough to log in with remember me active.

This default path can also be changed as follows:

.rememberMe().rememberMeParameter("remember-me-new")

The mechanism will create an additional cookie – the “remember-me” cookie – when the user logs in.

The Remember Me cookie contains the following data:

username – to identify the logged-in principal
expirationTime – to expire the cookie; default is 2 weeks
MD5 hash – of the previous 2 values – username and expirationTime, plus the password and the predefined key

The first thing to notice here is that both the username and the password are part of the cookie – this means that, if either is changed, the cookie is no longer valid. Also, the username can be read from the cookie.

Additionally, it is important to understand that this mechanism is potentially vulnerable if the remember me cookie is captured. The cookie will be valid and usable until it expires or the credentials are changed.

5. In Practice

To easily see the remember me mechanism working, you can:

log in with remember me active
wait for the session to expire (or remove the JSESSIONID cookie in the browser)
refresh the page

Without remember me active, after the cookie expires the user should be redirected back to the login page. With remember me, the user now stays logged in with the help of the new token/cookie.

6. Conclusion

This tutorial showed how to set up and configure Remember Me functionality in the security configuration, and briefly described what kind of data goes into the cookie.

The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.

When the project runs locally, the login.html can be accessed on localhost.