Authentification personnalisée au printemps

Question

J'ai une question. Dans Struts, j'ai une action qui traite de l'authentification de l'utilisateur, c'est-à-dire que j'ai pris les informations d'identification de l'utilisateur et utilisé un DAO pour valider les informations d'identification de l'utilisateur. Je veux maintenir la même configuration au printemps. J'utilise Spring 3.0.3 RELEASE.

Ma question est, j'ai lu Spring Security et là, il spécifie JDBC backend "Validation" fournisseur. Je veux savoir, comment, si l'utilisateur a cliqué sur "login" qu'il soumet les informations d'identification à mon contrôleur pour vérifier l'authentification valide?

La raison pour laquelle je veux faire cela est que j'ai un service qui gère l'authentification et l'autorisation des utilisateurs.

Merci d'avance.

PS Comment sécuriser un contrôleur au printemps?
PPS Je suis nouveau au printemps

Answer 1

Vous pouvez vous écrire propre mécanisme de validation pour le printemps sécurité. Il devra se compose de pièces suivantes:

• Auth Filtre - lit les données de demande, puis appelez Auth fournisseur avec jeton des informations d'identification (instance de l'authentification de classe)
• Auth Fournisseur - accepte ce jeton (filtre auth peut créer différents tokents, et il peut y avoir différents fournisseurs auth, pour chaque type de jeton), et essayez de vous authentifier (en appelant votre service, dans votre cas). Après auth vous pouvez (ou non) appel utilisateur Détails Service ou remplir toutes les données utilisateur là
• Détails utilisateur service - charge signé en détails de l'utilisateur de quelque part (de jdbc, autre service, etc.)

Answer 2

Habituellement Spring Security gère l'authentification dans son propre code, en utilisant votre code comme stratégie (fournisseurs d'authentification, services de détails de l'utilisateur, etc.). Mais vous pouvez gérer l'authentification dans votre propre code.

Dans le code de votre action, lorsque les informations d'identification de l'utilisateur sont corrects, vous:

• Créer un Authentication contenant le nom d'utilisateur et les rôles accordés (vous pouvez utiliser UsernamePasswordAuthenticationToken comme la mise en œuvre pratique).
• le mettre dans le contexte de sécurité:
  SecurityContextHolder.getContext().setAuthentication(auth);
• diffusion de l'événement succès d'authentification à l'aide AuthenticationEventPublisher.publishAuthenticationSuccess(...) (vous pouvez lier automatiquement à partir du contexte ou créer un explicitement DefaultAuthenticationEventPublisher).
• Redirige l'utilisateur vers la ressource sécurisée à l'aide de SavedRequestAwareAuthenticationSuccessHandler.onAuthenticationSuccess(...).

vous devez également fournir un AuthenticationEntryPoint:

<bean id = "aep" class = "org.springframework.security.web.authentication.LoginUrlAuthenticationEntryPoint"> 
    <!-- Your login page --> 
    <property name = "loginFormUrl" value = "/login" /> 
</bean> 

<security:http entry-point-ref="aep"> 
    ... 
</http> 

Cependant, si vous êtes réellement nouveau au printemps, il peut être préférable d'éviter une telle personnalisation massives et utiliser l'architecture de sécurité Spring régulière.

Answer 3

Vous pouvez créer un fournisseur d'authentification personnalisé qui implémente org.springframework.security.authentication.AuthenticationProvider comme celui-ci

package com.bzone.example; 

import org.springframework.security.authentication.AuthenticationProvider; 
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken; 
import org.springframework.security.core.Authentication; 
import org.springframework.security.core.AuthenticationException; 


public class CustomAuthenticationProvider implements AuthenticationProvider{ 

    @Override 
    public Authentication authenticate(Authentication authentication) 
      throws AuthenticationException { 
     // TODO call custom service or do whatever you want 
     return null; 
    } 

    @Override 
    public boolean supports(Class<? extends Object> authentication) { 
     // copied it from AbstractUserDetailsAuthenticationProvider 
     return (UsernamePasswordAuthenticationToken.class.isAssignableFrom(authentication)); 
    } 

} 

une étape supplémentaire consiste à configurer la sécurité de printemps pour utiliser ce fournisseur d'authentification personnalisé

<?xml version="1.0" encoding="UTF-8"?> 
<beans:beans xmlns="http://www.springframework.org/schema/security" 
    xmlns:beans="http://www.springframework.org/schema/beans" 
    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-3.0.xsd"> 

    <!-- HTTP security configurations --> 
    <http auto-config="true" use-expressions="true"> 
     <form-login login-processing-url="/static/j_spring_security_check" login-page="/login" authentication-failure-url="/login?login_error=t"/> 
     <logout logout-url="/static/j_spring_security_logout"/> 

     <!-- Configure these elements to secure URIs in your application --> 
     <intercept-url pattern="/member/**" access="isAuthenticated()" /> 
     <intercept-url pattern="/resources/**" access="permitAll" /> 
     <intercept-url pattern="/static/**" access="permitAll" /> 
     <intercept-url pattern="/**" access="permitAll" /> 
    </http> 

    <!-- Configure Authentication mechanism --> 
    <authentication-manager alias="authenticationManager"> 
     <authentication-provider ref="com.bzone.example.CustomAuthenticationProvider" /> 
    </authentication-manager> 

</beans:beans>