[JAVA] Comment Spring Security fonctionne avec Hello World

Auto-introduction

De quoi parler aujourd'hui

Expliquez les bases du fonctionnement de Spring Security à travers un bref Hello World

――Quels types de classes fonctionnent ensemble et comment

Contexte

Paramètres abstraits

Personne cible

En apprenant comment fonctionne Spring Security via Hello World

Connaissances préalables

--Dispose d'une bonne connaissance de Servlet et JSP

  • En sachant Filter etc., vous pouvez écrire web.xml pour créer une application Servlet
  • Possède une bonne connaissance du printemps
  • Comprendre les haricots et les AOP de ce que sont les conteneurs DI

Application Hello World (prémisse)

N'utilisez pas Spring Boot

  • Le but est d'apprendre les bases de Spring Security --Utilisez uniquement Spring Security

N'utilisez pas Java Config

  • Ecrire les paramètres en xml ――Après tout, Java Config est le même

N'utilisez pas les fonctionnalités du Servlet 3.0

--Si vous utilisez la fonction de Servlet 3.0, vous pouvez la définir sans web.xml. ――Le but est d'apprendre les bases du mécanisme, alors ne l'utilisez pas non plus.

Application Hello World (construction d'environnement)

La source

https://github.com/opengl-8080/spring-security-hello-world

Environnement de vérification de fonctionnement

  • Java 1.8.0_121
  • Tomcat 8.0.35

Obtenez le fichier de guerre

-Téléchargez spring-security.war depuis ici

  • Si vous construisez à partir des sources, téléchargez la source et exécutez gradlew war à la racine de votre projet.

Contrôle de fonctionnement

--Déployez spring-security.war sur Tomcat --Accès http: // localhost: 8080 / spring-security

Application Hello World (opération)

Accédez à http: // localhost: 8080 / spring-security

spring-security.jpg

Entrez foo dans User, Password pour vous connecter

spring-security.jpg

Erreur 403

Ensuite, connectez-vous avec bar

spring-security.jpg

spring-security.jpg

La page d'index s'affiche.

Vous pouvez vous déconnecter en cliquant sur le bouton de déconnexion.

Application Hello World (mise en œuvre)

organisation des fichiers


|-build.gradle :Fichier de construction Gradle
|
`-src/main/webapp/
  |
  |-index.jsp :Sommaire
  |
  `-WEB-INF/
    |
    |-applicationContext.xml :Fichier de configuration Spring
    |
    `-web.xml :Fichier de configuration du servlet

--Tous les 4 fichiers ―― One est un fichier de construction, donc trois fichiers sont effectivement déployés.

  • Configuration ultra-simple sans aucune source Java

build.gradle


apply plugin: 'war'

sourceCompatibility = '1.8'
targetCompatibility = '1.8'
compileJava.options.encoding = 'UTF-8'

repositories {
    mavenCentral()
}

dependencies {
    compile 'org.springframework.security:spring-security-web:4.2.1.RELEASE'
    compile 'org.springframework.security:spring-security-config:4.2.1.RELEASE'
}

war.baseName = 'spring-security'

task wrapper(type: Wrapper) {
    gradleVersion = '3.2.1'
}

index.jsp


<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!doctype html>
<html>
  <head>
    <meta charset="utf-8" />
    <title>
      Hello Spring Security!!
    </title>
  </head>
  <body>
    <h1>
      Hello Spring Security!!
    </h1>
    
    <form action="logout" method="post">
      <input type="submit"
             value="logout" />
      <input type="hidden"
             name="${_csrf.parameterName}"
             value="${_csrf.token}" />
    </form>
  </body>
</html>

--Page supérieure affichée après la connexion

  • Juste un message et un bouton de déconnexion -- _csrf est défini car il est activé par défaut, mais comme il n'apparaîtra pas dans l'explication suivante, une explication détaillée sera omise.
  • Pour plus de détails, veuillez vous reporter à Spring Security Usage Memo CSRF | Qiita.

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">

  <listener>
    <listener-class>
      org.springframework.web.context.ContextLoaderListener
    </listener-class>
  </listener>
  
  <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>
</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() and hasAuthority('BAR')" />
    <sec:form-login />
    <sec:logout />
  </sec:http>
  
  <sec:authentication-manager>
    <sec:authentication-provider>
      <sec:user-service>
        <sec:user name="foo"
                  password="foo"
                  authorities="" />
        <sec:user name="bar"
                  password="bar"
                  authorities="BAR" />
      </sec:user-service>
    </sec:authentication-provider>
  </sec:authentication-manager>
</beans>

Lire Hello World

  1. Démarrez la demande d'acceptation du serveur
  2. Entrée Spring Security
  3. Processus de connexion
  4. Contrôle d'accès
  5. Processus de déconnexion

Lire Hello World

  1. ** Démarrer la demande de réception du serveur **
  2. Entrée Spring Security
  3. Processus de connexion
  4. Contrôle d'accès
  5. Processus de déconnexion

Initialisation du conteneur Spring

web.xml


<listener>
  <listener-class>
    org.springframework.web.context.ContextLoaderListener
  </listener-class>
</listener>
  • <listener>
  • La fonction Servlet vous permet de définir le processus à exécuter au démarrage de l'application.
  • ContextLoaderListener --Classe qui initialise le conteneur Spring --Par défaut, XmlWebApplicationContext est utilisé --WEB-INF / applicationContext.xml est utilisé comme fichier de configuration

Enregistrement de DelegatingFilterProxy

web.xml


  <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>
  • Enregistrez un filtre nommé DelegatingFilterProxy avec le nom springSecurityFilterChain --Filter est une fonction fournie par Servlet
  • Un traitement arbitraire peut être inséré avant et après la demande --Spécifiez / * pour ʻurl-pattern` pour traiter toutes les requêtes

Rôle de DelegatingFilterProxy

DelegatingFilterProxyの役割.png

--DelegatingFilterProxy recherche dans le conteneur Spring les beans qui correspondent aux critères suivants:

  • Le nom du bean correspond à son nom de filtre (springSecurityFilterChain)
  • Implémentation de l'interface javax.servlet.Filter
  • Déléguer le traitement au bean acquis
  • Puisque la classe à laquelle DelegatingFilterProxy a délégué le traitement est un bean obtenu à partir du conteneur Spring, les fonctions du conteneur Spring peuvent être utilisées.
    • DI
    • AOP
    • etc...
  • Le rôle de DelegatingFilterProxy est de relier le conteneur Servlet et le conteneur Spring.

Paramètres de sécurité Spring

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="/**"
            access="isAuthenticated() and hasAuthority('BAR')" />
    <sec:form-login />
    <sec:logout />
  </sec:http>

  ...

--ʻApplicationContext.xmlest le fichier de configuration Spring --Définissez un bean en utilisant la balise` --Pas un fichier de configuration dédié à Spring Security

  • Une balise dédiée est fournie pour vous permettre d'écrire les paramètres de Spring Security de manière concise.
  • Appelé ** namespace ** dans la référence
  • Lecture avec xmlns: sec

<http> est la clé

applicationContext.xml


  <sec:http>
    ...
  </sec:http>

--Ce <http> est la clé pour configurer Spring Security --Un grand nombre de grains importants sont enregistrés

FilterChainProxy --Un des beans enregistrés par la balise <http> --Hériter de l'interface Filter

  • Enregistré dans le conteneur Spring avec le nom springSecurityFilterChain
  • L'identité du bean délégué par DelegatingFilterProxy

Résumé (Démarrer la requête de réception du serveur) </ span>

test

  1. Le conteneur de servlet démarre et ContextLoaderListener, qui est enregistré comme Listener dans web.xml, est exécuté.
  2. Une instance de XmlWebApplicationContext est créée et / WEB-INF / applicationContext.xml est chargé.
  3. La balise <http> enregistre une instance de FilterChainProxy avec le conteneur Spring avec le nom" "springSecurityFilterChain" .
  4. DelegateFilterProxy, qui est enregistré comme Filter dans web.xml, est généré par le conteneur de servlet.
  5. À la demande, DelegateFilterProxy est appelé pour récupérer le bean du conteneur Spring avec son propre nom ("springSecurityFilterChain") ( FilterChainProxy est obtenu).
  6. Le traitement est délégué à FilterChainProxy.
  • Strictement parlant, cela peut ne pas être correct car il est facile à comprendre. Veuillez regarder l'atmosphère.

Lire Hello World

  1. Démarrer la demande de réception du serveur </ del>
  2. ** Entrée Spring Security **
  3. Processus de connexion
  4. Contrôle d'accès
  5. Processus de déconnexion

SecurityFilterChain --Une des classes importantes que <http> enregistre

  • Comme son nom l'indique, «Filter» est enchaîné. --FilterChainProxy délègue la demande reçue aux Filters de SecurityFilterChain
  • Exemple de Filtre enregistré par défaut
    • SecurityContextPersistenceFilter
    • CsrfFilter
    • AnonymousAuthenticationFilter
    • ExceptionTranslationFilter
    • FilterSecurityInterceptor
    • etc...

Sécurité et filtre Spring

SpringSecurityとFilter.jpg

--Spring Security est réalisé par une combinaison de Filter

  • Un Filter est préparé pour chaque fonction, et vous pouvez activer / désactiver la fonction en enregistrant le Filter dans le SecurityFilterChain.

SecurityFilterChain pour chaque modèle d'URL

patternごとのSecurityFilterChain.jpg

--SecurityFilterChain peut être défini pour chaque modèle d'URL

  • Pour accéder à une URL qui correspond à / api / **, utilisez le jeu SecurityFilterChain pour l'API REST.
  • Pour accéder à d'autres URL (/ **), utilisez le jeu SecurityFilterChain pour un accès normal à l'écran. --Peut être dit --Par exemple, des fonctions telles que "Connexion par formulaire" ne sont plus nécessaires lors de l'accès avec l'API REST.

Le fichier de configuration ressemble à ceci:

applicationContext.xml


  <sec:http pattern="/api/**">
    ...
  </sec:http>
  
  <sec:http pattern="/**">
    ...
  </sec:http>

--Spécifiez dans l'attribut pattern de la balise <http> (Peut être spécifié au format Ant)

  • Les paramètres sont appliqués dans l'ordre du haut, alors amenez celui avec les paramètres les plus limités vers le haut. (Si le paramètre / ** est supérieur à / api / **, l'accès à / api / ** correspondra d'abord au paramètre / **)

Résumé (entrée Spring Security) </ span>

--<http>enregistre SecurityFilterChain comme un bean --SecurityFilterChain contient plusieursFilters --Spring Security fournit un filtre pour chaque fonction

  • En combinant Filter, vous pouvez définir SecurityFilterChain avec seulement les fonctions nécessaires.
  • Puisque SecurityFilterChain peut être défini pour chaque modèle d'URL, --SecurityFilterChain pour l'API REST --SecurityFilterChain pour un accès normal à l'écran Peut être mis en place

patternごとのSecurityFilterChain.jpg

Lire Hello World

  1. Démarrer la demande de réception du serveur </ del>
  2. Entrée Spring Security </ del>
  3. ** Processus de connexion **
  4. Contrôle d'accès
  5. Processus de déconnexion

Activer la connexion par formulaire

applicationContext.xml


  <sec:http>
    ...
    <sec:form-login />
    ...
  </sec:http>
  • L'ajout de la balise ` 'permet la connexion par formulaire
  • Le Filtre requis pour la connexion par formulaire est ajouté à SecurityFilterChain

Page de connexion par défaut

spring-security.jpg

--Si l'attribut «login-page» de «» n'est pas spécifié, un «Filtre» appelé «DefaultLoginPageGeneratingFilter» est enregistré. --Génère et renvoie une simple page de connexion lorsqu'il y a une requête de méthode GET dans / login

  • Pratique lorsque vous souhaitez essayer le contrôle de fonctionnement rapidement
  • Une case à cocher pour Remember-Me est automatiquement ajoutée lorsque l'authentification Remember-Me est activée.

Traitement des demandes de connexion

  • Le traitement de la connexion est effectué par Filter appelé ʻUsernamePasswordAuthenticationFilter`
  • Lorsqu'une requête de la méthode POST arrive à / login, le processus d'authentification démarre.
  • Cependant, le processus d'authentification proprement dit est délégué à ʻAuthenticationManager`.

AuthenticationManagerに委譲.png

Veuillez noter que beaucoup de "délégation" sort d'ici et c'est déroutant! </ span>

AuthenticationManager

applicationContext.xml


  <sec:authentication-manager> ★
    <sec:authentication-provider>
      <sec:user-service>
        <sec:user name="foo" ... />
        <sec:user name="bar" ... />
      </sec:user-service>
    </sec:authentication-provider>
  </sec:authentication-manager>
  • En déclarant la balise <authentication-manager>, ProviderManager, qui est une classe d'implémentation de ʻAuthenticationManager, est enregistré dans le conteneur Spring. --Classe qui est l'entrée du processus d'authentification --Cependant, ProviderManager lui-même n'effectue pas de traitement d'authentification et ** délègue ** à ʻAuthenticationProvider.

ProviderManagerとAuthenticationProvider.png

ProviderManager et AuthenticationProvider

AuthenticationProviderの実装クラス達.png

--ʻAuthenticationProvider a de nombreuses classes d'implémentation pour chaque type d'authentification --ProviderManager contient plusieurs instances de ʻAuthenticationProvider selon la méthode d'authentification prise en charge par l'application. --Chaque ʻAuthenticationProvider est fait pour juger si la demande d'authentification actuelle est prise en charge, et si elle est prise en charge, le processus d'authentification est effectué par ʻAuthenticationProvider. --ProviderManager est responsable de la gestion de plusieurs ʻAuthenticationProvider ensemble (exactement ProviderManager`).

AuthenticationProvider pour l'authentification par mot de passe

applicationContext.xml


  <sec:authentication-manager>
    <sec:authentication-provider> ★
      <sec:user-service>
        <sec:user name="foo" ... />
        <sec:user name="bar" ... />
      </sec:user-service>
    </sec:authentication-provider>
  </sec:authentication-manager>
  • En utilisant la balise <authentication-provider>, une classe appelée DaoAuthenticationProvider est enregistrée comme une implémentation de ʻAuthenticationProvider. --DaoAuthenticationProvider` effectue le traitement d'authentification en utilisant une combinaison de nom d'utilisateur et de mot de passe.
  • À ce moment-là, utilisez Dao (Data Access Object) pour obtenir des informations sur l'utilisateur.
  • La partie correspondant à Dao est ** déléguée ** à ʻUserDetailsService`.

UserDetailsServiceに委譲.png

UserDetailsService

UserDetailsService


public interface UserDetailsService {

    UserDetails
        loadUserByUsername(String username)
            throws UsernameNotFoundException;
}

--Dispose d'une méthode qui renvoie les informations utilisateur (ʻUserDetails`) en fonction du nom d'utilisateur

  • Jetez ʻUsernameNotFoundException` si aucun utilisateur n'est trouvé --Spring Security fournit plusieurs classes qui implémentent cette interface

InMemoryUserDetailsManager Implémentation pour enregistrer les informations utilisateur en mémoire

JdbcUserDetailsManager Implémentation qui récupère les informations utilisateur de la base de données via JDBC

Utiliser InMemoryUserDetailsManager

applicationContext.xml


  <sec:authentication-manager>
    <sec:authentication-provider>
      <sec:user-service> ★
        <sec:user name="foo" ... />
        <sec:user name="bar" ... />
      </sec:user-service>
    </sec:authentication-provider>
  </sec:authentication-manager>
  • L'utilisation de la balise <user-service> entraîne l'enregistrement de ʻInMemoryUserDetailsManager dans le conteneur Spring en tant qu'implémentation de ʻUserDetailsService.

UserDetails

UserDetails.java


public interface UserDetails extends Serializable {

    String getUsername();
    String getPassword();
    Collection<? extends GrantedAuthority>
        getAuthorities();

    boolean isAccountNonExpired();
    boolean isAccountNonLocked();
    boolean isCredentialsNonExpired();
    boolean isEnabled();
}

--ʻUserDetails` est une interface qui fournit des informations détaillées sur l'utilisateur connecté.

  • Vous pouvez obtenir le statut tel que le nom d'utilisateur et le mot de passe, la collecte des privilèges accordés, expirés et verrouillés. --Une classe appelée ʻUser` est préparée comme une classe qui implémente cette interface.

Utiliser l'utilisateur

applicationContext.xml


  <sec:authentication-manager>
    <sec:authentication-provider>
      <sec:user-service>
        <sec:user name="foo" ... /> ★
        <sec:user name="bar" ... /> ★
      </sec:user-service>
    </sec:authentication-provider>
  </sec:authentication-manager>

--Lors de l'utilisation de la balise <user>, les informations utilisateur sont générées à l'aide de la classe ʻUser`.

  • Les informations utilisateur générées sont stockées dans <user-service>, c'est-à-dire ʻInMemoryUserDetailsManager`.

Organisez le flux jusqu'à présent

ログイン処理整理.png

  1. Lorsqu'une requête POST arrive à / login, ʻUsernamePasswordAuthenticationFilter` effectue le processus d'authentification.
  2. Le traitement de l'authentification est délégué à ʻAuthenticationManager`
  3. ProviderManager, qui est une classe d'implémentation de ʻAuthenticationManager, délègue le processus d'authentification à son propre ʻAuthenticationProvider.
  4. DaoAuthenticationProvider enregistré avec la balise <authentication-provider> effectue un traitement d'authentification basé sur le nom d'utilisateur et le mot de passe.
  5. À ce moment-là, la recherche d'informations sur l'utilisateur est déléguée à ʻUserDetailsService`.
  6. ʻInMemoryUserDetailsManager enregistré avec la balise stocke les informations utilisateur (ʻUserDetails) définies avec la balise <user> en mémoire.

Les relations ci-dessus sont incluses dans les paramètres ci-dessous.

applicationContext.xml


  <sec:authentication-manager>
    <sec:authentication-provider>
      <sec:user-service>
        <sec:user name="foo" ... />
        <sec:user name="bar" ... />
      </sec:user-service>
    </sec:authentication-provider>
  </sec:authentication-manager>

Si l'authentification réussit

AuthenticationProvider.java


public interface AuthenticationProvider {

    Authentication authenticate(Authentication authentication)
        throws AuthenticationException;
}
  • Si le processus d'authentification de ʻAuthenticationProvider réussit, l'objet ʻAuthentication qui contient les informations de l'utilisateur connecté est renvoyé. --Cet objet ʻAuthentication` est enregistré dans la session et sera référencé dans les futures requêtes, etc.

Résumé (processus de connexion) </ span>

--<form-login>active l'authentification par formulaire --ʻUsernamePasswordAuthenticationFilter est ajouté et le processus d'authentification démarre --ʻAuthenticationManager contrôle le processus d'authentification --ʻAuthenticationProvider effectue un processus d'authentification spécifique --ʻUserDetailsService récupère les informations utilisateur Dao --ʻUserDetails` fournit des informations détaillées sur l'utilisateur

  • Si l'authentification réussit, l'objet ʻAuthentication` est enregistré dans la session.

Lire Hello World

  1. Démarrer la demande de réception du serveur </ del>
  2. Entrée Spring Security </ del>
  3. Processus de connexion </ del>
  4. ** Contrôle d'accès **
  5. Processus de déconnexion

FilterSecurityInterceptor

  • Un des Filters importants ajoutés en définissant la balise <http> --- Insérez le processus avant et après l'exécution du processus de ** Secure Object **
  • Le contrôle d'accès pour les requêtes HTTP est lancé dans ce FilterSecurityInterceptor

Objet sécurisé

  • ** Les objets protégés ** sont appelés ** Objet sécurisé ** dans la référence Spring Security.
  • Bien qu'il dise "Objet", il est utilisé pour désigner l'objet "objet" original plutôt qu'un objet Java spécifique (probablement).
  • "Requête HTTP vers une URL spécifique" ou "méthode d'exécution" est un objet sécurisé.

Délégation de contrôle d'accès

AccessDecisionManagerに委譲.png

--FilterSecurityInterceptor lui-même ne vérifie pas le contrôle d'accès

  • Le jugement du contrôle d'accès est délégué à ʻAccessDecisionManager`

Contrôle d'accès par vote

投票によるアクセス制御

  • La classe d'implémentation de ʻAccessDecisionManager fournie par Spring Security contrôle l'accès par "** vote **". --ʻAccessDecisionManager laisse ʻAccessDecisionVoter` voter pour l'accès
  • Accordé: accessible </ font>
  • Refusé: Inaccessible </ font>
  • Abandon: non pris en charge </ font> --ʻAccessDecisionManager` regroupe les résultats du vote et tire une conclusion
  • Si oui, ne rien faire --Si impossible, lancez ʻAccessDeniedException`

Classe d'implémentation AccessDecisionManager

AccessDecisionManagerと実装クラス.png

--ʻAccessDecisionManager` a trois classes d'implémentation

  • AffirmativeBased --Accessible s'il y a même une "subvention" --Cette classe est utilisée par défaut
  • ConsensusBased --Accessible si "Rejeter" <"Donner"
  • UnanimousBased --Accessible si tous sont "accordés"

Contrôle d'accès basé sur les expressions

applicationContext.xml


  <sec:http>
    <sec:intercept-url
            pattern="/login"
            access="permitAll" />
    <sec:intercept-url
            pattern="/**"
            access="isAuthenticated() and hasAuthority('BAR')" />
    ...
  </sec:http>

--ʻWebExpressionVoter est utilisé par défaut pour implémenter AccessDecisionVoter --ʻExpression` C'est-à-dire contrôler l'accessibilité en fonction d'expressions

  • L'expression de contrôle d'accès est spécifiée par l'attribut ʻaccess de la balise `.
  • L'attribut pattern spécifie le modèle de l'URL à laquelle le contrôle s'applique.

Spring Expression Language (SpEL)

applicationContext.xml


  access="permitAll"
  access="isAuthenticated() and hasAuthority('BAR')"

--Utilisez le propre langage d'expression de Spring appelé Spring Expression Language pour les expressions de contrôle d'accès --Assurez-vous que le résultat de l'évaluation de l'expression est booléen --Si true, accessible </ font> --Si false, inaccessible </ font>

  • Les fonctions et les constantes ont été étendues pour Spring Security --permitAll: Toujours vrai --ʻIsAuthenticated () : true si authentifié --hasAuthority () : true` si vous avez l'autorité spécifiée

Résumé (contrôle d'accès) </ span>

  • Le contrôle d'accès est démarré avec FilterSecurityInterceptor
  • Le contrôle réel est effectué par ʻAccessDecisionManager`
  • L'implémentation standard utilise le «vote» pour déterminer l'accès.
  • votes ʻAccessDecisionVoter, et ʻAccessDecisionManager agrège les résultats du vote et tire une conclusion.
  • Par défaut, le contrôle d'accès basé sur les expressions utilisant SpEL par WebExpressionVoter est activé.

Lire Hello World

  1. Démarrer la demande de réception du serveur </ del>
  2. Entrée Spring Security </ del>
  3. Processus de connexion </ del>
  4. Contrôle d'accès </ del>
  5. ** Processus de déconnexion **

Activer la déconnexion

applicationContext.xml


  <sec:http>
    ...
    <sec:logout />
  </sec:http>

--Utiliser la balise <logout> ajoute un LogoutFilter

  • Lorsqu'une requête POST arrive à / logout, LogoutFilter gère la déconnexion.

Regard en arrière sur l'ensemble

Réception des demandes de démarrage du serveur

test

Entrée Spring Security

SpringSecurityとFilter.jpg

Processus de connexion

ログイン処理整理.png

Contrôle d'accès

投票によるアクセス制御

C'est la seule signification de ce paramètre

web.xml


<?xml version="1.0" encoding="UTF-8"?>
<web-app ...>
  <listener>
    <listener-class>
      org.springframework.web.context.ContextLoaderListener
    </listener-class>
  </listener>
  
  <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>
</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"
       ...>

  <sec:http>
    <sec:intercept-url
            pattern="/login"
            access="permitAll" />
    <sec:intercept-url
            pattern="/**"
            access="isAuthenticated() and hasAuthority('BAR')" />
    <sec:form-login />
    <sec:logout />
  </sec:http>
  
  <sec:authentication-manager>
    <sec:authentication-provider>
      <sec:user-service>
        <sec:user name="foo"
                  password="foo"
                  authorities="" />
        <sec:user name="bar"
                  password="bar"
                  authorities="BAR" />
      </sec:user-service>
    </sec:authentication-provider>
  </sec:authentication-manager>
</beans>

Comment était-ce?
Spring Security Pensiez-vous que c'était facile? </ span>

[Triste nouvelle] Toujours Hello World

Fonctionnalités et éléments dont je ne parle pas aujourd'hui

  • GrantedAuthority
  • Superposition des rôles --Sécurité des méthodes
  • CSRF
  • Memember-Me
  • Encodage du mot de passe --Diverses méthodes de personnalisation --Tester
  • etc...

Mais si l'histoire d'aujourd'hui est une base de connaissances,
elle devrait être surmontée (probablement) </ span>

c'est tout

Recommended Posts