spring security 源码分析 之 认证过程

最新推荐文章于 2024-06-28 16:26:27 发布
置顶 最新推荐文章于 2024-06-28 16:26:27 发布
阅读量194 收藏
点赞数
分类专栏： spring security 文章标签： spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41291945/article/details/108032954
版权

spring_security

介绍

spring_security 的分析主要包括认证和授权两个部分， 并且站在分析源码的角度探究整个执行过程以及原理。

  • 认证
  • 授权

组件版本

  • spring boot 2.2.4.RELEASE
  • springfox-swagger 2 2.4.0
  • spring-boot-starter-data-jpa 2.2.4.RELEASE
  • mysql 5.7

认证

认证

认证就是判断当前用户是否是一个合法用户， 即对比用户输入的用户名密码和数据库中的是否一致，但是这个查询过程是交由security来处理的，并且security会把当前的登陆用户保存到 中以便我们在全局都可以直接得到当前的登陆用户。

登陆分析

1、依赖

        <!--   以下是spring security依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>

2、配置

security 中的认证过程主要是帮助我们校验登录用户的合法性，其中框架本身已经帮助我们做出了大量的封装，登录界面以及校验逻辑都已经做完了，我们需要做的就是简单的配置使得security集成到当前的项目中~具体的集成方法不会描述，本文笔记重在描述整个认证的流程，**我们将从登录界面开始说起一点点深入。**前置的知识点，认证管理器、配置密码加密规则、认证。

@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
   /**
    * 配置用户的服务信息
    *        //  manager.createUser(User.withUsername("cyt").password("$2a$10$I9pgiXNbkct5cPlhHMvXfe4J7xk1akU6mIWArNTTAihvHUn1jSkpK").authorities("vip").build());
    *         // manager.createUser(User.withUsername("ccc").password("$2a$10$I9pgiXNbkct5cPlhHMvXfe4J7xk1akU6mIWArNTTAihvHUn1jSkpK").authorities("v").build());
    * @return
    */
/*    @Override
   @Bean
   public UserDetailsService userDetailsService() {
       InMemoryUserDetailsManager manager = new InMemoryUserDetailsManager();

       return manager;
   }*/

   /**
    * 配置密码的规则
    *
    * @return
    */
   @Bean
   public PasswordEncoder passwordEncoder() {
       return new BCryptPasswordEncoder();
   }

   @Override
   protected void configure(HttpSecurity http) throws Exception {
       http
               .authorizeRequests()//开启登录配置
               .antMatchers("/test").hasAnyAuthority("vip1") //表示访问 /test 这个接口，需要具备 vip1 这个角色
               .antMatchers("/cyt").hasAnyAuthority("vip2")
               .antMatchers("/cyt/test").hasAnyAuthority("vip3")
               .anyRequest().permitAll() //表示剩余的其他接口，随便访问
               .and()
               .formLogin() // 登陆表单
               .successForwardUrl("/success"); // 成功后的路由跳转
   }

.formLogin() // 登陆表单

点开此源码

  • getOrApply中传入的是一个配置， 然后本身是一个过滤器链 DefaultSecurityFilterChain
	public FormLoginConfigurer<HttpSecurity> formLogin() throws Exception {
		return getOrApply(new FormLoginConfigurer<>());
	}
  • 在这个配置中调用了父类了构造器并且传递一个认证过滤器
	public FormLoginConfigurer() {
		super(new UsernamePasswordAuthenticationFilter(), null);
		usernameParameter("username");
		passwordParameter("password");
	}
  • UsernamePasswordAuthenticationFilter 中继续调用父类，并传递 AntPathRequestMatcher
	public UsernamePasswordAuthenticationFilter() {
		super(new AntPathRequestMatcher("/login", "POST"));
	}
  • AbstractAuthenticationProcessingFilter 是一个过滤器， 看他的doFilter
	public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)
			throws IOException, ServletException {

        	// 得到请求
		HttpServletRequest request = (HttpServletRequest) req;
		HttpServletResponse response = (HttpServletResponse) res;
			// 不需要认证直接放行
		if (!requiresAuthentication(request, response)) {
			chain.doFilter(request, response);

			return;
		}

		if (logger.isDebugEnabled()) {
			logger.debug("Request is to process authentication");
		}
			// 认证的结果
		Authentication authResult;

		try {
            // 尝试认证
			authResult = attemptAuthentication(request, response);
			if (authResult == null) {
				// return immediately as subclass has indicated that it hasn't completed
				// authentication
				return;
			}
			sessionStrategy.onAuthentication(authResult, request, response);
		}
		catch (InternalAuthenticationServiceException failed) {
			logger.error(
					"An internal error occurred while trying to authenticate the user.",
					failed);
		// 认证失败
            unsuccessfulAuthentication(request, response, failed);

			return;
		}
		catch (AuthenticationException failed) {
			// Authentication failed
            	// 认证失败
			unsuccessfulAuthentication(request, response, failed);

			return;
		}

		// Authentication success
		if (continueChainBeforeSuccessfulAuthentication) {
			chain.doFilter(request, response);
		}
			// 认证成功
		successfulAuthentication(request, response, chain, authResult);
	}

开始逐一分析上述的几个重要方法

attemptAuthentication

  • UsernamePasswordAuthenticationFilter 实际调用子类
    • 从请求中得到用户名和密码
    • 封装成一个用户名密码认证token
    • 放入 setDetails
    • 交由认证管理器认证
	public Authentication attemptAuthentication(HttpServletRequest request,
			HttpServletResponse response) throws AuthenticationException {
		if (postOnly && !request.getMethod().equals("POST")) {
			throw new AuthenticationServiceException(
					"Authentication method not supported: " + request.getMethod());
		}

		String username = obtainUsername(request);
		String password = obtainPassword(request);

		if (username == null) {
			username = "";
		}

		if (password == null) {
			password = "";
		}

		username = username.trim();

		UsernamePasswordAuthenticationToken authRequest = new UsernamePasswordAuthenticationToken(
				username, password);

		// Allow subclasses to set the "details" property
		setDetails(request, authRequest);

		return this.getAuthenticationManager().authenticate(authRequest);
	}

ProviderManager

认证管理器使用子类ProviderManager 中的认证方法， result = provider.authenticate(authentication); 在此方法中执行主要逻辑。其中ProviderManager 的认证方法会遍历所有的 AuthenticationProvider 子类然后逐一认证。这里我们关注 AbstractUserDetailsAuthenticationProvider
在这里插入图片描述

		for (AuthenticationProvider provider : getProviders()) {
			if (!provider.supports(toTest)) {
				continue;
			}

			if (debug) {
				logger.debug("Authentication attempt using "
						+ provider.getClass().getName());
			}

			try {
				result = provider.authenticate(authentication);

				if (result != null) {
					copyDetails(authentication, result);
					break;
				}
			}
			catch (AccountStatusException | InternalAuthenticationServiceException e) {
				prepareException(e, authentication);
				// SEC-546: Avoid polling additional providers if auth failure is due to
				// invalid account status
				throw e;
			} catch (AuthenticationException e) {
				lastException = e;
			}
		}

AbstractUserDetailsAuthenticationProvider

AbstractUserDetailsAuthenticationProvider 本身是一个抽象类，方法会有子类实现, 在它的认证方法中先去缓存中获取用户，如果没有的话会 调用 retrieveUser(username,(UsernamePasswordAuthenticationToken) authentication);其中的authentication 就是之前认证管理器中传递的authRequest = new UsernamePasswordAuthenticationToken( username, password);

username 也就是UsernamePasswordAuthenticationToken 中的username.

		boolean cacheWasUsed = true;
		UserDetails user = this.userCache.getUserFromCache(username);

		if (user == null) {
			cacheWasUsed = false;

			try {
                // 关键代码
				user = retrieveUser(username,
						(UsernamePasswordAuthenticationToken) authentication);
			}
			catch (UsernameNotFoundException notFound) {
				logger.debug("User '" + username + "' not found");

				if (hideUserNotFoundExceptions) {
					throw new BadCredentialsException(messages.getMessage(
							"AbstractUserDetailsAuthenticationProvider.badCredentials",
							"Bad credentials"));
				}
				else {
					throw notFound;
				}
			}

			Assert.notNull(user,
					"retrieveUser returned null - a violation of the interface contract");
		}

		try {
             // 关键代码
			preAuthenticationChecks.check(user);
             // 关键代码
			additionalAuthenticationChecks(user,
					(UsernamePasswordAuthenticationToken) authentication);
		}
		catch (AuthenticationException exception) {
			if (cacheWasUsed) {
				// There was a problem, so try again after checking
				// we're using latest data (i.e. not from the cache)
				cacheWasUsed = false;
				user = retrieveUser(username,
						(UsernamePasswordAuthenticationToken) authentication);
				preAuthenticationChecks.check(user);
				additionalAuthenticationChecks(user,
						(UsernamePasswordAuthenticationToken) authentication);
			}
			else {
				throw exception;
			}
		}

 		// 关键代码
		postAuthenticationChecks.check(user);

		if (!cacheWasUsed) {
			this.userCache.putUserInCache(user);
		}

		Object principalToReturn = user;

		if (forcePrincipalAsString) {
			principalToReturn = user.getUsername();
		}
 		// 关键代码
		return createSuccessAuthentication(principalToReturn, authentication, user);

retrieveUser

DaoAuthenticationProvider extends AbstractUserDetailsAuthenticationProvider

会默认调用DaoAuthenticationProvider 中的实现 在其方法中只是实现了一个逻辑： 根据用户名获得其用户信息返回一个 UserDetailss

UserDetails loadedUser = this.getUserDetailsService().loadUserByUsername(username);

loadUserByUsername

UserDetailsService 是一个接口 其中是有一个 loadUserByUsername方法， 查看到其子类的实现，有基于内存、基于jdbc以及缓存等，慢慢的就和上面的分析对上了。当然还有我们自己定义的实现。这里就找到了从数据库中查询用户信息交由security做认证的第一步。接下来还需要对比数据库中查询到的密码是否和用户在表单中输入的密码一致

在这里插入图片描述

additionalAuthenticationChecks(user, (UsernamePasswordAuthenticationToken) authentication);

  • user loadUserByUsername 方法根据表单中的用户名从数据库中查询到的用户信息
  • authentication security根据表单中的用户名密码封装成的token

这个方法才是对用户进行认证的，毕竟表单中输入的密可能是错误的噢

又回到了这个 AbstractUserDetailsAuthenticationProvider 然后调用子类 DaoAuthenticationProvider

	protected void additionalAuthenticationChecks(UserDetails userDetails,
			UsernamePasswordAuthenticationToken authentication)
			throws AuthenticationException {
        
        // 当前 token 无凭证 
		if (authentication.getCredentials() == null) {
			logger.debug("Authentication failed: no credentials provided");

			throw new BadCredentialsException(messages.getMessage(
					"AbstractUserDetailsAuthenticationProvider.badCredentials",
					"Bad credentials"));
		}
	// 得到表单中的用户密码
		String presentedPassword = authentication.getCredentials().toString();
//  更具之前配置的加密规则进行密码对比
		if (!passwordEncoder.matches(presentedPassword, userDetails.getPassword())) {
			logger.debug("Authentication failed: password does not match stored value");

			throw new BadCredentialsException(messages.getMessage(
					"AbstractUserDetailsAuthenticationProvider.badCredentials",
					"Bad credentials"));
		}
	}

这个方法执行完毕之后，会依次检查当前用户是否可以、是否过期信息、是否放入缓存。最后返回认证完毕的

UsernamePasswordAuthenticationToken

postAuthenticationChecks.check(user);
if (!cacheWasUsed) {
	this.userCache.putUserInCache(user);
}

认证成功！！！此时还记得我们从那个地方开始认证的吗？ ** 目前已经执行到了AbstractAuthenticationProcessingFilter** 中的 authResult = attemptAuthentication(request, response);

	protected Authentication createSuccessAuthentication(Object principal,
			Authentication authentication, UserDetails user) {
		// Ensure we return the original credentials the user supplied,
		// so subsequent attempts are successful even with encoded passwords.
		// Also ensure we return the original getDetails(), so that future
		// authentication events after cache expiry contain the details
		UsernamePasswordAuthenticationToken result = new UsernamePasswordAuthenticationToken(
				principal, authentication.getCredentials(),
				authoritiesMapper.mapAuthorities(user.getAuthorities()));
		result.setDetails(authentication.getDetails());

		return result;
	}

此时回到 AbstractAuthenticationProcessingFilter

		try {
            // 执行到这里了
			authResult = attemptAuthentication(request, response);
			if (authResult == null) {
				// return immediately as subclass has indicated that it hasn't completed
				// authentication
				return;
			}
             // 存到session中
			sessionStrategy.onAuthentication(authResult, request, response);
		}
		catch (InternalAuthenticationServiceException failed) {
			logger.error(
					"An internal error occurred while trying to authenticate the user.",
					failed);
			unsuccessfulAuthentication(request, response, failed);

			return;
		}
		catch (AuthenticationException failed) {
			// Authentication failed
			unsuccessfulAuthentication(request, response, failed);

			return;
		}

		// Authentication success  
		if (continueChainBeforeSuccessfulAuthentication) {
			// 这个   continueChainBeforeSuccessfulAuthentication  是个false 
            chain.doFilter(request, response);
		}

		successfulAuthentication(request, response, chain, authResult);

successfulAuthentication

  • SecurityContextHolder.getContext().setAuthentication(authResult);

把认证的用户存入到SecurityContext 中，以便可以全局获取当前的用户 ， 注意 authResult中是包含了我们当前的用户信息的。

  • rememberMeServices.loginSuccess(request, response, authResult);

把认证的用户存入到记住我中

  • successHandler.onAuthenticationSuccess(request, response, authResult);

会重定向到我们的登录成功界面。

	protected void successfulAuthentication(HttpServletRequest request,
			HttpServletResponse response, FilterChain chain, Authentication authResult)
			throws IOException, ServletException {

		if (logger.isDebugEnabled()) {
			logger.debug("Authentication success. Updating SecurityContextHolder to contain: "
					+ authResult);
		}

		SecurityContextHolder.getContext().setAuthentication(authResult);

		rememberMeServices.loginSuccess(request, response, authResult);

		// Fire event
		if (this.eventPublisher != null) {
			eventPublisher.publishEvent(new InteractiveAuthenticationSuccessEvent(
					authResult, this.getClass()));
		}

		successHandler.onAuthenticationSuccess(request, response, authResult);
	}
认证时序图

在这里插入图片描述

在这里插入图片描述

重点过程

对于整个的认证过程中需要注意的有一下几个：

  • UserDetails
    • 其中存放的都是security 定义的当前用户信息。
  • UsernamePasswordAuthenticationToken
  • Authentication
  • UserDetailsService
  • UsernamePasswordAuthenticationFilter

图示

在这里插入图片描述
在这里插入图片描述

崔雨田
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
3.springSecurity源码分析1
08-03
在深入分析SpringSecurity源码之前，我们先了解一些基础概念。 1. DelegatingFilterProxy：这是一个Spring框架提供的过滤器，它作为代理来调用实际的Filter。在web.xml中，filter-name设置为...
springsecurity源码（鉴权有缺陷）
05-20
Spring Security 是一个强大的安全框架，用于为 Java 应用程序提供认证和授权功能。然而，正如标题所提及的，Spring Security 的源码可能存在鉴权缺陷。这个话题涉及到多个知识点，包括Spring Security的基本架构、...
SpringSecurity（三）- SpringSecurity 原理
及时当勉励，岁月不待人
09-25 570
SpringSecurity（三）- SpringSecurity 原理
Spring Security基本源码解析（超精细版）
最新发布
边走、边悟、迟早变好
06-28 597
Spring 是非常流行和成功的 Java 应用开发框架， Spring Security 正是 Spring 家族中的 成员。 Spring Security 基于 Spring 框架，提供了一套 Web 应用安全性的完整解决方 案。
SpringSecurity源码分析
keep12moving的博客
09-11 173
1 在web.xml文件中配置 问题:为什么DelegatingFilterProxy的fifilter-name必须是springSecurityFilterChain? DelegatingFilterProxy并不是真正的Filter，在其initFilterBean方法中会从WebApplicationContext根据delegate 来获取到 在上这代码中this...
spring security 源码
05-28
本篇文章将深入探讨Spring Security的核心概念和源码分析。 1. **核心组件** - `SecurityContextHolder`: 它是Spring Security的核心，存储当前请求的安全上下文，包含认证信息和权限。 - `Authentication`: 表示...
SpringSecurity源码
05-29
在学习SpringSecurity源码时，建议从以下几个方面入手： 1. **源码结构分析**：了解主要组件的类结构和它们之间的关系，如`Authentication`、`Authorization`、`FilterChainProxy`等。 2. **关键类的实现**：深入...
spring security源码分析
qq_41904699的博客
12-01 255
使用IDEA查看源码 由于spring security是通过DelegatingFilterProxy整合的，这个框架相当于一个过滤器 <filter> <!-- DelegatingFilterProxy用于整合第三方框架 整合Spring Security时过滤器的名称必须为springSecurityFilterChain， 否则会抛出NoSuchBeanDefinitionException异常 --> &lt
Spring Security 源码分析
snkkka163的博客
07-26 401
Spring Security 源码分析 1.Spring Security基本执行流程分析: 现在假设我们要发送一个新的请求给我们的项目，默认我们的项目已经配置了Spring Security 这个请求会先进入 1.UsernamePasswordAuthenticationFilter: 验证我们的请求中是否有这个过滤器所需要的信息，比如说账号密码 如果说带了账号密码，那将会尝试使用这些参数进行登录，如果没有带这个过滤器所需要的参数，那就往下走，进入BasicAuthenticationFilter
Spring Security源码分析
not_say的博客
03-31 812
参考链接（主要参考此系列文章，截图和补充总结等由debug程序、阅读源码得出） https://juejin.im/post/5d8d66aee51d45783f5aa49e 一、三句话解释框架原理 1、整个框架的核心是一个过滤器，这个过滤器名字叫springSecurityFilterChain类型是FilterChainProxy 2、核心过滤器里面是过滤器链（列表），过滤器链的...
SpringSecurity源码解析
zheyangyebuxingaaa的博客
01-08 480
Springboot 下 SpringSecurity 的自动配置源码解读
Spring Security源码解析
ThisLX的博客
11-01 412
1、SecurityContextPersistenceFilter: SecurityContextPersistenceFilter有两个主要任务: 在请求到达时处理之前，从SecurityContextRepository中获取安全上下文信息填充到SecurityContextHolder; 在请求处理结束后返回响应时，将SecurityContextHolder中的安全上下文信息保存回S...
springsecurity源码分析
03-16
Spring Security 是一个基于 Spring 框架的安全框架，它提供了一系列的安全服务，包括身份...在源码分析过程中，我们可以学习到 Spring Security 的核心组件、流程和设计思想，以及如何扩展和定制 Spring Security。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值