[JAVA] Gestion des sessions de mémo d'utilisation de Spring Security

Histoire de base et systématique Histoire de certification / autorisation Histoire Remember-Me Histoire CSRF L'histoire de l'en-tête de la réponse Histoire de la sécurité de la méthode Histoire CORS L'histoire de Run-As Histoire ACL Test story Parlez de la coopération avec MVC et Boot

Edition supplémentaire Ce que Spring Security peut et ne peut pas faire

Contrôle du nombre de sessions simultanées

Par défaut, le même utilisateur peut créer plusieurs sessions. En d'autres termes, un même utilisateur peut se connecter autant de fois qu'il le souhaite à partir de différents terminaux.

En modifiant les paramètres, vous pouvez limiter le nombre de sessions simultanées ou empêcher les connexions multiples du tout.

Limiter le nombre de sessions simultanées

la mise en oeuvre

namespace

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee 
         http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1">
    
    <filter>
        <filter-name>springSecurityFilterChain</filter-name>
        <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
    </filter>

    <filter-mapping>
        <filter-name>springSecurityFilterChain</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    
    <listener>
        <listener-class>org.springframework.security.web.session.HttpSessionEventPublisher</listener-class>
    </listener>
</web-app>

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:sec="http://www.springframework.org/schema/security"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
         http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
         http://www.springframework.org/schema/security
         http://www.springframework.org/schema/security/spring-security.xsd">
    
    <sec:http>
        <sec:intercept-url pattern="/login" access="permitAll" />
        <sec:intercept-url pattern="/**" access="isAuthenticated()" />
        <sec:form-login />
        <sec:logout />
        
        <sec:session-management>
            <sec:concurrency-control max-sessions="1" />
        </sec:session-management>
    </sec:http>
    
    <sec:authentication-manager>
        <sec:authentication-provider>
            <sec:user-service>
                <sec:user name="hoge" password="hoge" authorities="" />
            </sec:user-service>
        </sec:authentication-provider>
    </sec:authentication-manager>
</beans>

Java Configuration

MySpringSecurityInitializer.java

package sample.spring.security;

import org.springframework.security.web.context.AbstractSecurityWebApplicationInitializer;

public class MySpringSecurityInitializer extends AbstractSecurityWebApplicationInitializer {
    public MySpringSecurityInitializer() {
        super(MySpringSecurityConfig.class);
    }

    @Override
    protected boolean enableHttpSessionEventPublisher() {
        return true;
    }
}

MySpringSecurityConfig.java

package sample.spring.security;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

import java.util.Collections;

@EnableWebSecurity
public class MySpringSecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    public void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                .antMatchers("/login").permitAll()
                .anyRequest().authenticated()
                .and()
                .formLogin()
                .and()
                .sessionManagement().maximumSessions(1);
    }
    
    @Autowired
    public void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
            .withUser("hoge")
            .password("hoge")
            .authorities(Collections.emptyList());
    }
}

Contrôle de fonctionnement

Connectez-vous avec le premier navigateur.

Connectez-vous avec le même utilisateur dans un autre navigateur.

Lorsque je réaffiche le premier navigateur, un message d'erreur s'affiche.

La description

web.xml

    <listener>
        <listener-class>org.springframework.security.web.session.HttpSessionEventPublisher</listener-class>
    </listener>

MySpringSecurityInitializer.java

    @Override
    protected boolean enableHttpSessionEventPublisher() {
        return true;
    }

• Vous devez enregistrer HttpSessionEventPublisher en tant qu'écouteur pour que Spring Security puisse détecter qu'une nouvelle session a été créée. --Si vous utilisez web.xml, déclarez-le normalement avec <auditeur>.
• Si vous utilisez WebApplicationInitializer, vous pouvez remplacer la méthode ʻenableHttpSessionEventPublisher ()pour retournertrue et elle enregistrera HttpSessionEventPublisher` comme écouteur.

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:sec="http://www.springframework.org/schema/security"
       ...>
    
    <sec:http>
        ...
        
        <sec:session-management>
            <sec:concurrency-control max-sessions="1" />
        </sec:session-management>
    </sec:http>
    
    ...
</beans>

--Ajoutez la balise <session-management>, ajoutez la balise <concurrency-control> et spécifiez le nombre maximum de sessions avec l'attribut max-sessions.

MySpringSecurityConfig.java

...

@EnableWebSecurity
public class MySpringSecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    public void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                ...
                .and()
                .sessionManagement().maximumSessions(1);
    }
    
    ...
}

--Spécifiez avec sessionManagement (). MaximumSessions (int).

Spécifiez l'écran d'erreur

Par défaut, l'écran n'affichera qu'un message d'erreur, alors passez à la page spécifiée (par exemple, la page de connexion).

namespace

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:sec="http://www.springframework.org/schema/security"
       ...>
    
    <sec:http>
        ...
        
        <sec:session-management >
            <sec:concurrency-control max-sessions="1" expired-url="/login" />
        </sec:session-management>
    </sec:http>
    
    ...
</beans>

--Spécifiez l'URL et le chemin dans l'attribut ʻexpired-url`.

Java Configuration

MySpringSecurityConfig.java

...

@EnableWebSecurity
public class MySpringSecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    public void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                ...
                .and()
                .sessionManagement().maximumSessions(1).expiredUrl("/login");
    }
    
    ...
}

--Spécifié par la méthode ʻexpiredUrl (String) `.

Précisez le traitement au moment de l'erreur dans l'implémentation

MySessionInformationExpiredStrategy.java

package sample.spring.security.session;

import org.springframework.security.web.DefaultRedirectStrategy;
import org.springframework.security.web.session.SessionInformationExpiredEvent;
import org.springframework.security.web.session.SessionInformationExpiredStrategy;

import javax.servlet.ServletException;
import java.io.IOException;

public class MySessionInformationExpiredStrategy implements SessionInformationExpiredStrategy {
    
    @Override
    public void onExpiredSessionDetected(SessionInformationExpiredEvent event) throws IOException, ServletException {
        DefaultRedirectStrategy redirectStrategy = new DefaultRedirectStrategy();
        redirectStrategy.sendRedirect(event.getRequest(), event.getResponse(), "/login");
    }
}

--Créez une classe qui implémente SessionInformationExpiredStrategy. La méthode --ʻOnExpiredSessionDetected () `implémente le traitement des erreurs.

• Ici, nous redirigeons vers / login.

namespace

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:sec="http://www.springframework.org/schema/security"
       ...>
    
    <bean id="sies" class="sample.spring.security.session.MySessionInformationExpiredStrategy" />
    
    <sec:http>
        ...
        
        <sec:session-management >
            <sec:concurrency-control max-sessions="1" expired-session-strategy-ref="sies" />
        </sec:session-management>
    </sec:http>
    
    ...
</beans>

--Spécifiez le bean de SessionInformationExpiredStrategy avec ʻexpired-session-strategy-ref`.

Java Configuration

MySpringSecurityConfig.java

...

import sample.spring.security.session.MySessionInformationExpiredStrategy;

@EnableWebSecurity
public class MySpringSecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    public void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                ...
                .and()
                .sessionManagement()
                    .maximumSessions(1)
                    .expiredSessionStrategy(new MySessionInformationExpiredStrategy());
    }
    
    ...
}

―― Enregistrez-vous avec la méthode ʻexpiredSessionStrategy (SessionInformationExpiredStrategy) `.

Vous empêcher de vous connecter au-delà de la limite

Si vous spécifiez simplement max-sessions ( maximumSessions), si vous vous connectez au-delà de la limite supérieure, la session la plus ancienne sera supprimée en premier.

Inversement, si vous essayez de vous connecter au-delà de la limite, vous pouvez faire une erreur si vous essayez de créer une nouvelle session. Cependant, sachez que si vous activez ce paramètre, vous ne pourrez peut-être pas vous reconnecter jusqu'à ce que votre ancienne session expire ou que vous vous déconnectiez explicitement.

namespace

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:sec="http://www.springframework.org/schema/security"
       ...>
    
    <sec:http>
        ...
        
        <sec:session-management >
            <sec:concurrency-control max-sessions="1" error-if-maximum-exceeded="true" />
        </sec:session-management>
    </sec:http>
    
    ...
</beans>

--Spécifiez «true» pour «erreur-si-maximum-dépassé».

Java Configuration

MySpringSecurityConfig.java

...

@EnableWebSecurity
public class MySpringSecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    public void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                ...
                .and()
                .sessionManagement()
                    .maximumSessions(1)
                    .maxSessionsPreventsLogin(true);
    }
    
    ...
}

• Passez true dans la méthode maxSessionsPreventsLogin (boolean).

** Contrôle de fonctionnement **

Connectez-vous avec le premier navigateur.

Si vous essayez de vous connecter avec le même utilisateur sur le deuxième navigateur, une erreur se produit.

Spécifiez la destination de la transition au moment de l'erreur

la mise en oeuvre

max-session-error.jsp

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8" />
        <title>Max Session</title>
    </head>
    <body>
        <h1>Le nombre de sessions a atteint la limite</h1>
        
        <%@page import="org.springframework.security.core.AuthenticationException" %>
        <%@page import="org.springframework.security.web.WebAttributes" %>
        <%
            AuthenticationException e = (AuthenticationException)session.getAttribute(WebAttributes.AUTHENTICATION_EXCEPTION);
            pageContext.setAttribute("errorMessage", e.getMessage());
        %>
        
        <h2 style="color: red;">${errorMessage}</h2>
    </body>
</html>

La page qui sera la destination de la transition. Un message d'erreur s'affiche.

namespace

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:sec="http://www.springframework.org/schema/security"
       ...>
    
    <sec:http>
        <sec:intercept-url pattern="/login" access="permitAll" />
        <sec:intercept-url pattern="/max-session-error.jsp" access="permitAll" />
        <sec:intercept-url pattern="/**" access="isAuthenticated()" />
        <sec:form-login authentication-failure-url="/max-session-error.jsp" />
        <sec:logout />
        
        <sec:session-management>
            <sec:concurrency-control max-sessions="1" error-if-maximum-exceeded="true" />
        </sec:session-management>
    </sec:http>
    
    ...
</beans>

Java Configuration

MySpringSecurityConfig.java

...

@EnableWebSecurity
public class MySpringSecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    public void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                .antMatchers("/login").permitAll()
                .antMatchers("/max-session-error.jsp").permitAll()
                .anyRequest().authenticated()
                .and()
                .formLogin()
                    .failureUrl("/max-session-error.jsp")
                .and()
                .sessionManagement()
                    .maximumSessions(1)
                    .maxSessionsPreventsLogin(true);
    }
    
    ...
}

Contrôle de fonctionnement

Connectez-vous avec le premier navigateur.

Lorsque vous vous connectez avec le deuxième navigateur, vous serez redirigé vers la page d'erreur spécifiée (max-session-error.jsp).

La description

applicationContext.xml

        <sec:intercept-url pattern="/login" access="permitAll" />
        <sec:intercept-url pattern="/max-session-error.jsp" access="permitAll" />
        <sec:intercept-url pattern="/**" access="isAuthenticated()" />
        <sec:form-login authentication-failure-url="/max-session-error.jsp" />

• Si le nombre de sessions dépasse la limite supérieure et que vous essayez de vous connecter à Form, la page d'erreur sera créée avec l'attribut ʻauthentication-failure-url de la balise `, qui est le paramètre de connexion au formulaire. ――Bien sûr, la page d'erreur qui est normalement ignorée par un mot de passe erroné, etc. sera la page spécifiée ici. ――Ainsi, en réalité, il semble nécessaire de spécifier l'URL de l'écran de connexion, d'identifier l'erreur du côté de l'écran de connexion (ou du contrôleur de l'écran de connexion), et de changer le message.
• Alternativement, vous pouvez choisir de gérer les erreurs d'authentification en spécifiant ʻAuthenticationFailureHandler dans ʻauthentication-failure-handler-ref (pour ʻAuthenticationFailureHandler`](http://qiita.com/opengl- " 8080 / items / 032ed0fa27a239bdc1cc #% E3% 83% AD% E3% 82% B0% E3% 82% A4% E3% 83% B3% E3% 81% AB% E5% A4% B1% E6% 95% 97% E3 % 81% 97% E3% 81% 9F% E3% 81% A8% E3% 81% 8D% E3% 81% AE% E5% 87% A6% E7% 90% 86% E3% 82% 92% E5% AE % 9F% E8% A3% 85% E3% 81% 99% E3% 82% 8B))
• En cas d'erreur de limite de session, SessionAuthenticationException est levée.

Pourquoi la connexion par formulaire est-elle définie?

Vérifié avec UsernamePasswordAuthenticationFilter

Pourquoi la spécification de la destination de transition lorsqu'une erreur se produit dans le contrôle du nombre maximum de sessions est-elle définie sur la balise <form-login>?

applicationContext.xml

        <sec:session-management>
            <sec:concurrency-control max-sessions="1" error-if-maximum-exceeded="true" />
        </sec:session-management>

--Lorsque vous ajoutez la balise <session-management>, un filtre appelé SessionManagementFilter est ajouté.

• Le nombre de sessions simultanées est vérifié par la classe SessionAuthenticationStrategy que ce filtre a.
• Plus précisément, ConcurrentSessionControlAuthenticationStrategy. --Cependant, cette SessionAuthenticationStrategy a également un ʻUsernamePasswordAuthenticationFilter` qui exécute le processus de connexion par formulaire.
• Strictement parlant, il est possédé par la classe parent ʻAbstractAuthenticationProcessingFilter`.
• ʻSi l'authentification avec UsernamePasswordAuthenticationFilterest réussie, le processus d'authentification lié à la session est délégué àSessionAuthenticationStrategy`.
• Et à ce moment-là, le nombre de sessions simultanées est vérifié.
• Si une erreur se produit qui dépasse la limite supérieure, il est naturel de gérer l'erreur avec ʻUsernamePasswordAuthenticationFilter. --SessionManagementFilter attend après ʻUsernamePasswordAuthenticationFilter. --Par conséquent, le paramètre de connexion par formulaire sera adopté pour la spécification de page d'erreur qui dépasse le nombre maximal de sessions.

Alors, quand SessionManagementFilter fonctionne-t-il?

--SessionManagementFilter est en charge du traitement lorsqu'il est connecté par un traitement d'authentification non interactif.

• Un processus d'authentification non interactif typique est la connexion automatique avec l'authentification Remember-Me.

Est-il possible de confier le traitement à SessionManagementFilter même lors de la connexion à Form?

Ceci est une estimation personnelle et je ne sais pas si c'est correct </ font>

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:sec="http://www.springframework.org/schema/security"
       ...>
    
    <sec:http>
        <sec:intercept-url pattern="/login" access="permitAll" />
        <sec:intercept-url pattern="/**" access="isAuthenticated()" />
        <sec:form-login />
        <sec:remember-me />
        <sec:logout />
        
        <sec:session-management>
            <sec:concurrency-control max-sessions="1" error-if-maximum-exceeded="true" />
        </sec:session-management>
    </sec:http>
    
    ...
</beans>

<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!doctype html>
<html>
    <head>
        <meta charset="utf-8" />
        <title>My Login Page</title>
    </head>
    <body>
        <h1>My Login Page</h1>
        
        <c:url var="loginUrl" value="/login" />
        <form action="${loginUrl}" method="post">
            <div>
                <label>Nom d'utilisateur: <input type="text" name="username" /></label>
            </div>
            <div>
                <label>mot de passe: <input type="password" name="password" /></label>
            </div>
            <div>
                <label>Remember-Me : <input type="checkbox" name="remember-me"></label>
            </div>
            <input type="submit" value="login" />
            <input type="hidden" name="${_csrf.parameterName}" value="${_csrf.token}" />
        </form>
    </body>
</html>

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:sec="http://www.springframework.org/schema/security"
       ...>
    
    <sec:http>
        <sec:intercept-url pattern="/login" access="permitAll" />
        <sec:intercept-url pattern="/my-login.jsp" access="permitAll" />
        <sec:intercept-url pattern="/**" access="isAuthenticated()" />
        <sec:form-login login-page="/my-login.jsp" />
        <sec:remember-me />
        <sec:logout />
        
        <sec:session-management session-authentication-error-url="/my-login.jsp">
            <sec:concurrency-control max-sessions="1" error-if-maximum-exceeded="true" />
        </sec:session-management>
    </sec:http>
    
    ...
</beans>

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:sec="http://www.springframework.org/schema/security"
       ...>

    <sec:http>
        ...
        <sec:session-management session-fixation-protection="none" />
    </sec:http>

    ...
</beans>

...

@EnableWebSecurity
public class MySpringSecurityConfig extends WebSecurityConfigurerAdapter {
    
    @Override
    public void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                ...
                .and()
                .sessionManagement()
                    .sessionFixation().none();
    }

    ...
}