spring security4 添加验证码

最新推荐文章于 2024-01-14 09:40:22 发布
最新推荐文章于 2024-01-14 09:40:22 发布
阅读量3.9k 收藏 2
点赞数 1
分类专栏： Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010425898/article/details/53690140
版权

spring security是一个很大的模块，本文中只涉及到了自定义参数的认证。spring security默认的验证参数只有username和password，一般来说都是不够用的。由于时间过太久，有些忘，可能有少许遗漏。好了，不废话。
spring以及spring security配置采用javaConfig，版本依次为4.2.5，4.0.4
总体思路：自定义EntryPoint，添加自定义参数扩展AuthenticationToken以及AuthenticationProvider进行验证。

首先定义EntryPoint：

import 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 extends LoginUrlAuthenticationEntryPoint {
    public MyAuthenticationEntryPoint(String loginFormUrl) {
        super(loginFormUrl);
    }
    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
        super.commence(request, response, authException);
    }
}

接下来是token，validCode是验证码参数:

import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;

public class MyUsernamePasswordAuthenticationToken extends UsernamePasswordAuthenticationToken {
    private String validCode;
    public MyUsernamePasswordAuthenticationToken(String principal, String credentials, String validCode) {
        super(principal, credentials);
        this.validCode = validCode;
    }
    public String getValidCode() {
        return validCode;
    }
    public void setValidCode(String validCode) {
        this.validCode = validCode;
    }
}

继续ProcessingFilter，

import com.core.shared.ValidateCodeHandle;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.AbstractAuthenticationProcessingFilter;
import org.springframework.security.web.util.matcher.AntPathRequestMatcher;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;

public class MyValidCodeProcessingFilter extends AbstractAuthenticationProcessingFilter {

    private String usernameParam = "username";
    private String passwordParam = "password";
    private String validCodeParam = "validateCode";

    public MyValidCodeProcessingFilter() {
        super(new AntPathRequestMatcher("/user/login", "POST"));
    }

    @Override
    public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException, IOException, ServletException {
        String username = request.getParameter(usernameParam);
        String password = request.getParameter(passwordParam);
        String validCode = request.getParameter(validCodeParam);
        valid(validCode, request.getSession());
        MyUsernamePasswordAuthenticationToken token = new MyUsernamePasswordAuthenticationToken(username, password, validCode);
        return this.getAuthenticationManager().authenticate(token);
    }

    public void valid(String validCode, HttpSession session) {
        if (validCode == null) {
            throw new ValidCodeErrorException("验证码为空!");
        }
        if (!ValidateCodeHandle.matchCode(session.getId(), validCode)) {
            throw new ValidCodeErrorException("验证码错误!");
        }
    }
}

分别定义三个参数，用于接收login表单过来的参数，构造方法给出了login的url以及需要post方式
接下来就是认证了，此处还没到认证用户名和密码的时候，只是认证了验证码
下面是ValidateCodeHandle一个工具类以及ValidCodeErrorException:

import java.util.concurrent.ConcurrentHashMap;

public class ValidateCodeHandle {

    private static ConcurrentHashMap validateCode = new ConcurrentHashMap<>();

    public static ConcurrentHashMap getCode() {
        return validateCode;
    }

    public static void save(String sessionId, String code) {
        validateCode.put(sessionId, code);
    }

    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;
    }

}

这里需要继承AuthenticationException以表明它是security的认证失败,这样才会走后续的失败流程

import org.springframework.security.core.AuthenticationException;

public class ValidCodeErrorException extends AuthenticationException {

    public ValidCodeErrorException(String msg) {
        super(msg);
    }

    public ValidCodeErrorException(String msg, Throwable t) {
        super(msg, t);
    }
}

接下来是Provider：

import org.springframework.security.authentication.BadCredentialsException;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.authentication.dao.DaoAuthenticationProvider;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.core.userdetails.UserDetails;

public class MyAuthenticationProvider extends DaoAuthenticationProvider {

    @Override
    public boolean supports(Class<?> authentication) {
        return MyUsernamePasswordAuthenticationToken.class.isAssignableFrom(authentication);
    }

    @Override
    protected void additionalAuthenticationChecks(UserDetails userDetails, UsernamePasswordAuthenticationToken authentication) throws AuthenticationException {
        Object salt = null;
        if (getSaltSource() != null) {
            salt = getSaltSource().getSalt(userDetails);
        }
        if (authentication.getCredentials() == null) {
            logger.debug("Authentication failed: no credentials provided");
            throw new BadCredentialsException("用户名或密码错误!");
        }

        String presentedPassword = authentication.getCredentials().toString();

        if (!this.getPasswordEncoder().isPasswordValid(userDetails.getPassword(), presentedPassword, salt)) {
            logger.debug("Authentication failed: password does not match stored value");

            throw new BadCredentialsException("用户名或密码错误!");
        }

    }
}

其中supports方法指定使用自定义的token，additionalAuthenticationChecks方法和父类的逻辑一模一样，我只是更改了异常返回的信息。
接下来是处理认证成功和认证失败的handler

import 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 extends SimpleUrlAuthenticationSuccessHandler {

    public FrontAuthenticationSuccessHandler(String defaultTargetUrl) {
        super(defaultTargetUrl);
    }

    @Override
    public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
        super.onAuthenticationSuccess(request, response, authentication);
    }
}
import 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 extends SimpleUrlAuthenticationFailureHandler {

    public FrontAuthenticationFailureHandler(String defaultFailureUrl) {
        super(defaultFailureUrl);
    }

    @Override
    public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) throws IOException, ServletException {
        super.onAuthenticationFailure(request, response, exception);
    }
}

最后就是最重要的security config 了：

import com.service.user.CustomerService;
import com.web.filter.SiteMeshFilter;
import com.web.mySecurity.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.annotation.Order;
import org.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;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.crypto.password.StandardPasswordEncoder;
import org.springframework.security.web.access.ExceptionTranslationFilter;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import org.springframework.security.web.context.AbstractSecurityWebApplicationInitializer;
import org.springframework.web.filter.CharacterEncodingFilter;

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
@EnableWebSecurity
public class SecurityConfig extends AbstractSecurityWebApplicationInitializer {

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new StandardPasswordEncoder("MD5");
    }

    @Autowired
    private CustomerService customerService;

    @Configuration
    @Order(1)
    public static class FrontendWebSecurityConfigureAdapter extends WebSecurityConfigurerAdapter {

        @Autowired
        private MyValidCodeProcessingFilter myValidCodeProcessingFilter;

        @Override
        protected void configure(HttpSecurity http) throws Exception {
            http.csrf().disable()  
                    .authorizeRequests()
                    .antMatchers("/user/login", "/user/logout").permitAll()
                    .anyRequest().authenticated()
                    .and()
                    .addFilterBefore(myValidCodeProcessingFilter, UsernamePasswordAuthenticationFilter.class)
                    .formLogin()
                    .loginPage("/user/login")
                    .and()
                    .logout()
                    .logoutUrl("/user/logout")
                    .logoutSuccessUrl("/user/login");
        }

    }

    @Bean(name = "frontAuthenticationProvider")
    public MyAuthenticationProvider frontAuthenticationProvider() {
        MyAuthenticationProvider myAuthenticationProvider = new MyAuthenticationProvider();
        myAuthenticationProvider.setUserDetailsService(customerService);
        myAuthenticationProvider.setPasswordEncoder(passwordEncoder());
        return myAuthenticationProvider;
    }

    @Bean
    public AuthenticationManager authenticationManager() {
        List<AuthenticationProvider> list = new ArrayList<>();
        list.add(frontAuthenticationProvider());
        AuthenticationManager authenticationManager = new ProviderManager(list);
        return authenticationManager;
    }

    @Bean
    public MyValidCodeProcessingFilter myValidCodeProcessingFilter(AuthenticationManager authenticationManager) {
        MyValidCodeProcessingFilter filter = new MyValidCodeProcessingFilter();
        filter.setAuthenticationManager(authenticationManager);
        filter.setAuthenticationSuccessHandler(frontAuthenticationSuccessHandler());
        filter.setAuthenticationFailureHandler(frontAuthenticationFailureHandler());
        return filter;
    }

    @Bean
    public FrontAuthenticationFailureHandler frontAuthenticationFailureHandler() {
        return new FrontAuthenticationFailureHandler("/user/login");
    }

    @Bean
    public FrontAuthenticationSuccessHandler frontAuthenticationSuccessHandler() {
        return new FrontAuthenticationSuccessHandler("/front/test");
    }

    @Bean
    public MyAuthenticationEntryPoint myAuthenticationEntryPoint() {
        return new MyAuthenticationEntryPoint("/user/login");
    }

}

首先是一个加密类的bean，customerService是一个简单的查询用户

@Service("customerService")
public class CustomerServiceImpl implements CustomerService {

    @Autowired
    private UserDao userDao;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        return  userDao.findCustomerByUsername(username);
    }
}

下来就是FrontendWebSecurityConfigureAdapter了，重写了configure方法，先禁用csrf，
开启授权请求authorizeRequests()，其中”/user/login”, “/user/logout”放过权限验证，
其他请求需要进行登录认证，
然后是addFilterBefore()，把我自定义的myValidCodeProcessingFilter添加到security默认的UsernamePasswordAuthenticationFilter之前，也就是先进行我的自定义参数认证，
然后是formLogin()，配置登录url以及登出url，登录登出url都需要进行controller映射，也就是要自己写controller。
接下来就是AuthenticationProvider，AuthenticationManager，ProcessingFilter，AuthenticationFailureHandler，AuthenticationSuccessHandler，EntryPoint的bean显示声明。
下面是login.jsp

<body>
<div class="login_div">
    <form:form autocomplete="false" commandName="userDTO" method="post">
        <div>
            <span class="error_tips"><b>${SPRING_SECURITY_LAST_EXCEPTION.message}</b></span>
        </div>
        username:<form:input path="username" cssClass="form-control"/><br/>
        password:<form:password path="password" cssClass="form-control"/><br/>
        validateCode:<form:input path="validateCode" cssClass="form-control"/>
        <label>${validate_code}</label>
        <div class="checkbox">
            <label>
                <input type="checkbox" name="remember-me"/>记住我
            </label>
        </div>
        <input type="submit" class="btn btn-primary" value="submit"/>
    </form:form>
</div>
</body>

验证码验证失败的时候抛出的是ValidCodeErrorException，由于它继承AuthenticationException，security在验证的时候遇到AuthenticationException就会触发AuthenticationFailureHandler，上面的bean中声明了认证失败跳转到登录url，所以login.jsp里面有${SPRING_SECURITY_LAST_EXCEPTION.message}获取我认证时抛出异常信息，能友好的提示用户。

整个自定义security验证流程就走完了

眉宇下的小格调
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【SpringSecurity系列】自定义认证逻辑
java_pfx的博客
05-06 294
今日分享开始啦，请大家多多指教~ 有小伙伴会说，自定义认证逻辑还不简单？是的，没错，无论是添加登录验证码还是修改登录数据库格式，都需要对认证逻辑作出调整。 之前我们自定义的一个核心思路就是自定义过滤器，在过滤器中做各种各样我们想做的事。 举一个简单的例子，在添加登录验证码中，我为了校验验证码就自定义了一个过滤器，并把这个自定义的过滤器放入 SpringSecurity 过滤器链中，每次请求都会通过该过滤器。但实际上，只需要登录请求经过该过滤器即可，其他请求是不需要经过该过滤器的，这个时候，大家是不是就发现弊
spring security4 添加验证码的示例代码
08-28
在Spring Security 4中，如果你需要添加验证码功能来增强用户登录的安全性，可以通过自定义组件来实现。以下是一个具体的步骤介绍： 1. **自定义入口点（EntryPoint）**： 通常，当用户尝试访问受保护的资源但未...
Spring Security 3.1 中功能强大的加密工具 PasswordEncoder
qq_34096082的博客
08-01 2874
3.1.0版本中新的PasswordEncoder继承关系 而在Spring-Security 3.1.0 版本之后，Spring-security-crypto模块中的password包提供了更给力的加密密码的支持，这个包中也有PasswordEncoder接口，接口定义如下。     Public interface PasswordEncoder{       String
使用Hutool生成和验证图形验证码
weixin_33894640的博客
12-17 3301
为什么80%的码农都做不了架构师？>>> ...
Spring Security 验证码
vengu733的博客
10-27 1429
原理、存在问题、解决思路我们知道Spring Security是通过过滤器链来完成了，所以它的解决方案是创建一个过滤器放到Security的过滤器链中，在自定义的过滤器中比较验证码。
前后端分离项目SpringBoot+SpringSecurity 图片验证码登录功能的实现（详细）
qq_62923382的博客
01-28 4686
前后端分离项目基础登录流程前后端分离项目中无法使用session，所以使用jwt生成token令牌作为客户端进行请求的一个标识，当用户第一次登录后，服务器生成一个token并将此token返回给客户端，以后客户端只需带上这个token前来请求数据即可，无需再次带上用户名和密码。springsecurity + 基础不带验证码登录功能的实现。
Spring Security登录添加验证码的实现过程
08-25
Spring Security 登录添加验证码的实现过程 在本文中，我们将学习如何在 Spring Security 框架中添加验证码功能。验证码是登录系统中常见的需求，网上也有非常成熟的解决方案。为了在 Spring Security 框架中实现这...
Spring Security 实现短信验证码登录功能
08-19
在本文中，我们将深入探讨如何使用Spring Security框架实现短信验证码登录功能。Spring Security是一个强大的安全框架，用于管理和保护Web应用程序的访问控制。在传统的用户名密码登录方式之外，短信验证码登录提供...
SpringSecurity实现图形验证码功能实例代码
08-26
可以在Spring Security的过滤链中添加自定义过滤器，用于在用户登录或其他需要验证码的表单提交时进行验证码的验证。这通常涉及到拦截请求，提取验证码，然后与会话中的验证码进行比较。 7. **考虑安全性**： ...
Spring Security 图片验证码功能的实例代码
08-27
接下来，我们需要在Spring Security的配置中添加这个验证码过滤器。这通常涉及到自定义一个`Filter`实现，然后在安全配置中定义其位置，确保它位于登录过滤器之前。这样，每次用户尝试登录时，都会先经过验证码过滤...
Spring Boot整合Spring Security（四）在登录界面添加验证码
时雨吹雪的博客
01-31 3663
Spring Security，在自定义登录界面添加验证码
springboot2.0--结合spring security5.0进行权限控制，从数据库中取权限信息及增加验证码
热门推荐
fycghy0803的专栏
06-01 1万+
1.在pom.xml中增加spring security jar的引用:     &lt;!--引入spring security--&gt; &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-security&...
Spring Security自定义验证码登录
大后生大大大的博客
11-19 2100
验证码登录
Spring Security实战（二）—— 实现图形验证码
weixin_49561506的博客
04-15 2965
spring security实现图形验证码
SpringSecurity实现验证码功能
weixin_41359273的博客
03-23 2496
SpringSecurity实现验证码功能1.pom.xml2.建表语句3. application.properties4.model5.mapper及其对应的xml文件6.UserService7.controller8.验证码配置9.自定义AuthenticationProvider,对验证码进行校验10.security配置11.测试 1.pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://ma
SpringSecurity（03）——图形验证码和短信验证码
最新发布
peng_gx的博客
01-14 811
SpringSecurity图形验证码和短信验证码
SpringSecurity
Gavin
03-22 1460
Spring Security是一个高度自定义的安全框架。利用Spring IoC/DI和AOP功能，为系统提供了声明式安全访问控制功能，减少了为系统安全而编写大量重复代码的工作。 Spring Boot配置不多，但它做了很多。功能摘要如下： 要求经过身份验证的用户才能与应用程序进行任何交互 1,生成默认登录表单 让用户名和密码记录到控制台
Spring Security OAuth2 授权码模式 (Authorization Code)
a294634473的博客
04-23 5067
前言 Spring Security OAuth2 授权码模式 (Authorization Code) 应该是授权登录的一个行业标准 整体流程 首先在平台注册获取CLIENT_ID和CLIENT_SECRET 即应用id和key 第三方通过请求重定向到平台的登录页面 输入平台的账号密码之后点击确认重定向到第三方的页面并携带code 通过code获取token 通过token获取用户信息 code的实现逻辑 自带的InMemoryAuthorizationCodeServices是用Concurre
初识spring security
code_mzh的博客
08-23 417
什么是认证 进入移动互联网时代，大家每天都在刷手机，常用的软件有微信、支付宝、头条等，下边拿微信来举例子说明认证相关的基本概念，在初次使用微信前需要注册成为微信用户，然后输入账号和密码即可登录微信，输入账号和密码登录微信的过程就是认证。 系统为什么要认证？ 认证是为了保护系统的隐私数据与资源，用户的身份合法方可访问该系统的资源。 认证 ：用户认证就是判断一个用户的身份是否合法的过程，用户去访问系统资源时系统要求验证用户的身份信息，身份合法方可继续访问，不合法则拒绝访问。常见的用户身份认证方式有：用户名密码登
springsecurity 用户登陆验证码
12-31
以下是使用Spring Security实现用户登录验证码的两种方式： 方式一（自定义AuthenticationProvider）： 1. 在pom.xml文件中添加依赖： ```xml <groupId>org.springframework.boot <artifactId>spring-boot-...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值