Spring Security4 Código de muestra para agregar código de verificación

Spring Security es un módulo grande, y este artículo solo implica la autenticación de parámetros personalizados. Los parámetros de verificación predeterminados de la seguridad de Spring son solo nombre de usuario y contraseña, que generalmente no son suficientes. Debido a que el tiempo ha pasado demasiado tiempo, algunos olvidos y algunos de ellos pueden faltar. Ok, sin tonterías.
Las configuraciones de seguridad de primavera y primavera usan Javaconfig, y las versiones son 4.2.5 y 4.0.4 a su vez.
Idea general: Personalice el punto de entrada, agregue parámetros personalizados para extender la autenticación y autenticación Aprovidere para la verificación.

Primero definir EntryPoint:

 importar org.springframework.security.core.authenticationException; import org.springframework.security.web.authentication.loginurlauthenticationEntryPoint; import javax.servlet.servletexception; import javax.servlet.http.httpservletrequest; import javax.servlet.http.httpservletResponse; import java.io.ioException; public class myauthenticationEntryPoint extiende loginurlauthenticationEntrypoint {public myauthenticationEntryPoint (String logInformUrl) {super (logInformUrl); } @Override public void Commence (HttpServletRequest Solicitud, respuesta httpServletResponse, AuthenticationException Authexception) lanza IOException, ServletException {super.commence (solicitud, respuesta, autorrefception); }}

Siguiente es Token, ValidCode es el parámetro del código de verificación:

 importar org.springframework.security.authentication.UsernamePassWalDauthenticationToken; clase pública myUSernamePassWalDauthenticationToken extiende usernamePasswordAuthenticationToken {private String Validcode; public myUSernamePassWordAuthenticationToken (string principal, string credencials, string validcode) {super (principal, credencials); this.ValidCode = ValidCode; } public String getValidCode () {return validCode; } public void setValidCode (string validCode) {this.validCode = validCode; }}

Continuar procesandofilter,

 import com.core.shared.validateCodeHandle; import org.springframework.security.core.authentication; import org.springframework.security.core.authenticationException; import org.springframework.security.web.authentication.abstractAuthenticationProcessingFilter; org.springframework.security.web.util.matcher.antpathRequestMatcher; import javax.servlet.servletException; import javax.servlet.http.httpservletRequest; import javax.servlet.http.httpservletResponse; import; importar; import javax.servlet.http.httpsession; import java.io.ioexception; clase pública myValidCodeProcessingFilter extiende abstractAuthenticationProcessingFilter {String privado usernameSeMeCARAM = "UserName"; String private PasswordParam = "Password"; cadena privada validCodeParam = "ValidateCode"; public myValidCodeProcessingFilter () {super (new AntPathRequestMatcher ("/User/Login", "Post")); } @Override Public Authentication intentAuthentation (HttpServletRequest Solicitud, respuesta httpServletResponse) lanza AuthenticationException, IOException, ServletException {String UserName = request.getParameter (usernameSeMeam); Cadena contraseña = request.getParameter (PasswordParam); Cadena validCode = request.getParameter (validCodeParam); válido (validCode, request.getSession ()); MyUSernamePassWordAuthenticationToken token = new MyUSernamePassWalDauthenticationToken (nombre de usuario, contraseña, validCode); devuelve this.getAuthenticationManager (). Authenticate (token); } public void Valid (string validCode, httpsession session) {if (validCode == null) {throw new ValkCodeRorException ("¡ValidAtecode está vacío!"); } if (! validateCodeHandle.matchCode (session.getId (), validCode)) {Throw New ValidCodeRorException ("ValidCodeError!"); }}}

Defina tres parámetros por separado, que se utilizan para recibir los parámetros del formulario de inicio de sesión. El método de construcción proporciona la URL de inicio de sesión y el método posterior requerido

Lo siguiente es la autenticación. Antes de que haya llegado el nombre de usuario y la contraseña de la autenticación, acabo de autenticar el código de verificación.

Aquí hay una clase de herramientas ValidAteCodeHandle y ValidCodeRorException:

 import java.util.concurrent.concurrenthashmap; clase pública validateCodeHandle {private static concurrenthashmap validateCode = new concurrenthashmap <> (); public static concurrenthashmap getCode () {return ValidAteCode; } public static void save (string sessionId, código de cadena) {validateCode.put (sessionId, código); } public static string getValidateCode (String SessionId) {Object obj = ValidateCode.get (SessionId); if (obj! = null) {return string.ValueOf (obj); } return null; } public static Boolean Matchcode (String SessionId, String InputCode) {String SaveCode = getValidateCode (sessionId); if (saveCode.equals (inputCode)) {return true; } return false; }}

Aquí debe heredar autenticación, Excepción para indicar que es una falla de autenticación de seguridad, de modo que se seguirá el proceso de falla posterior.

 importar org.springframework.security.core.authenticationException; public class ValidCodeRorException extiende AuthenticationException {public ValidCodeRorException (String Msg) {super (msg); } public validCodeRorException (String MSG, Throwable t) {super (msg, t); }}

El siguiente es el proveedor:

 importar org.springframework.security.authentication.badcredententialSexception; import org.springframework.security.authentication.usernamePasswordAuthenticationToken; importar org.springframework.security.authentication.dao.daoutaticationProvider; import org.springframework.security.core.authenticationException; import org.springframework.security.core.userdetails.userdetails; public class myauthenticationProvider extiende daoauthenticationProvider {@override soportes booleanos (class <?> Autenticación) {regreso MyUSernamePassWordAuthenticationToken.class.isassignableFrom (autenticación); } @Override vacío adicional Autenticación Atenticación (UserDetails userDetails, usernamePasswordAuthenticationToken Authentication) lanza AuthenticationException {object salt = null; if (getSaltSource ()! = null) {sal = getSaltSource (). getSalt (userDetails); } if (autenticación.getCredentials () == null) {logger.debug ("fallado de autenticación: no se proporcionan credenciales"); tirar nueva badcredentialSexception ("¡Error de nombre de usuario o contraseña!"); } Cadena PresentedPassword = Authentication.getCredentials (). ToString (); if (! this.getPassWordEncoder (). IsPasswordValid (userDetails.getPassword (), PresentedPassword, Salt)) {logger.debug ("Fallado de autenticación: la contraseña no coincide con el valor almacenado"); tirar nueva badcredentialSexception ("¡bajo nombre de usuario o contraseña!"); }}}

El método de soporte especifica el uso de un token personalizado, y el método adicional de AuthenticationChecks es exactamente el mismo que la lógica de la clase principal, acabo de cambiar la información devuelta por la excepción.

El siguiente es el controlador que maneja la autenticación exitosa y la autenticación fallida

 importar org.springframework.security.core.authentication; import org.springframework.security.web.authentication.simpleurlauthenticationsuccessHandler; import javax.servlet.servletexception; import javax.servlet.http.httpservletRequest; import javax.servlet.http.httpservletResponse; import java.io.ioException; public class frontAuthenticationSuccessHandler extiende SimpleUrlauthenticationsuccessHandler {public FrontAuthenticationsuccessHandler (String DefaultTargeturl) {Super (PredidTtargGerGoGegetUrl); } @Override public void onAuthenticationSuccess (HttpServletRequest Solicitud, respuesta httpServletResponse, autenticación de autenticación) lanza ioexception, servletException {super.aonauthenticationsuccess (solicitud, respuesta, autenticación); }}

 importar org.springframework.security.core.authenticationException; import org.springframework.security.web.authentication.simpleurlauthenticationFailureHandler; import javax.servlet.servletException; import javax.servlet.http.httpservletRequest; import javax.servlet.http.httpservletResponse; import java.io.ioException; public class frontAuthenticationFailureHandler extiende SimpleUrlauthenticationFailureHandler {public FrontAuthenticationFailureHandler (String DefailureUreurl) {Super (SuperFailureUrl); } @Override public void onAuthenticationFailure (solicitud httpservletRequest, respuesta httpServletResponse, excepción de EXCEPTION de autenticación) lanza ioexception, servletException {super.onauthenticationFailure (solicitud, respuesta, excepción); }}

Finalmente, la configuración de seguridad más importante:

 import com.service.user.customerservice; import com.web.filter.sitemeshfilter; import com.web.mysecurity.*; import org.springframework.beans.factory.annotation.aUtowired; import og.springfframework.context.annotation.bean; import; import org.springframework.context.annotation.Configuration; import org.springframework.core.annotation.order; import og.springframework.security.authentication.authenticationManager; import org.springframework.security.authentication.authenticationProvider; import org.springframework.security.authentication.providermanager; import org.springframework.security.config.annotation.web.builders.httpsecurity; importar org.springframework.security.config.annotation.web.configuration.enablewebsecurity; org. org. org.springframework.web.filter.characteriCodingFilter; import javax.servlet.dispatcherType; import javax.servlet.filterRegistration; import javax.servlet.servletContext; import java.util.arraylist; import java.util.enumset; import java.util.list;@configuration@enablewebsecuritypublic class SecurityConfig extiende AbstractSeCurityWebApplicationInitializer {@Bean public PasswordEncoder contraseña contraseña () {return New StandardPassWordEncoder ("MD5"); } @AUtowired privado CustomerService CustomerService; @Configuration @order (1) public static class frontendwebsecurityConfigureadapter extiende WebSecurityConfigurerAdapter {@aUtowired MyValidCodeprocessingFilter myValidCodeprocessingFilter; @Override protegido void configure (httpsecurity http) lanza la excepción {http.csrf (). Disable () .authorizequests () .antmatchers ("/user/login", "/user/logrout"). Permitall () .AnyRequest (). .addfilterbefore (myValidCodeProcessingFilter, usernamePassWalDauthenticationFilter.class) .Formlogin () .loginPage ("/user/login") .and () .OGOUT () .logouturl ("/user/logOut") .logoutsucessurl ("/" user/user/"); }} @Bean (name = "frontAuthenticationProvider") public myauthenticationProvider frontAuthenticationProvider () {myauthenticationProvider myauthenticationProvider = newAuthenticationProvider (); MyauthenticationProvider.SetUserDetailsService (CustomerService); myauthenticationProvider.setPassWordEncoder (contraseña en la contraseña ()); return myauthenticationProvider; } @Bean Public AuthenticationManager AuthenticationManager () {list <ShenticationProvider> list = new ArrayList <> (); list.add (frontAuthenticationProvider ()); AutenticationManager AuthenticationManager = new Providermanager (lista); return AuthenticationManager; } @Bean public myValidCodeProSingFilter myValidCodeProcessingFilter (AuthenticationManager AuthenticationManager) {myValidCodeProcessingFilter Filter = new MyValidCodeprocessingFilter (); Filter.setAuthenticationManager (AuthenticationManager); Filter.setAuthenticationSuccessHandler (frontAuthenticationSuccessHandler ()); Filter.setAuthenticationFailureHandler (frontAuthenticationFailureHandler ()); Filtro de retorno; } @Bean public FrontAuthenticationFailureHandler frontAuthenticationFailureHandler () {return New frontAuthenticationFailureHandler ("/user/login"); } @Bean Public frontAuthenticationsUccessHandler frontAuthenticationsUccessHandler () {return New frontAuthenticationSuccessHandler ("/front/test"); } @Bean public myauthenticationEntryPoint myauthenticationEntryPoint () {return new MyAAuthenticationEntryPoint ("/User/Login"); }}

En primer lugar, es un frijol de la clase de cifrado, y CustomerService es un usuario de consulta simple

 @Service ("CustomerService") Class Public ClasserviceImpl implementa CLIESSERVICE {@aUtowired userDao userDao; @Override Public UserDetails LoadUserByUserName (String UserName) lanza usernamenotfoundException {return userDao.findCustomerByUsername (nombre de usuario); }}

El siguiente es frontendwebsecurityConfigureadapter. Reescribí el método Configurar, primero desactivar CSRF, habilitar autorizequests (), donde "/usuario/inicio de sesión" y "/usuario/inicio de sesión", deje de lado la verificación del permiso, y otras solicitudes requieren autenticación de inicio de sesión, y luego addFilterbeFore (). Antes de agregar mi MyValidCodeProcessingFilter personalizado al UserNamePasswordAuthenticationFilter predeterminado en seguridad, primero realizo mi autenticación de parámetros personalizados, y luego formlogin (), configure URL de inicio de sesión y URL de inicio de sesión, y URL de inicio de sesión, URL de inicio de sesión, URL de inicio de sesión y URL de inicio de sesión para iniciar sesión URL, es decir, tengo que escribir un controlador usted mismo.
El siguiente es la declaración de la pantalla de Bean de autenticación, ProvenicationManager, ProcessingFilter, AuthenticationFailureHandler, AuthenticationCcessHandler y EntryPoint.

A continuación se muestra login.jsp

 <Body> <VInS> <Form: Form AUTOCOMPLETE = "FALSO" COMANDO = "USERDTO" METHOTO = "POST"> <VIV> <SPAPE> <B> $ {Spring_security_last_exception.message} </b> </span> </div> UserName: <Form: Enumer Path = "Password" CSSClass = "Form-Control"/> <br/> ValidateCode: <form: Input Path = "ValidateCode" CSSClass = "Form-Control"/> <label> $ {Validate_Code} </Label> valor = "enviar"/> </form: form> </div> </body>

Cuando el código de verificación falla, se lanza el validCodeRorException. Dado que hereda la AuthenticationException, cuando la seguridad encuentre la AuthenticationException, la autenticación de ALTOUREHANTER se activará. El bean anterior declara que la autenticación falló y salta a la URL de inicio de sesión, por lo que hay $ {Spring_Security_Last_Exception.message} en Login.jsp. La información de excepción se lanza cuando me autentico, lo que puede solicitar al usuario fácil de usar.

Se completa todo el proceso de verificación de seguridad personalizado

Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.