Spring Security 源码分析（二）【认证流程】

桃扇骨 2023-07-24 14:32 9阅读 0赞

> Spring Security 源码分析（一）【结构总览】：[https://yuanyu.blog.csdn.net/article/details/105469059][https_yuanyu.blog.csdn.net_article_details_105469059]

--------------------

# 1 认证流程 #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNzk0OTcz_size_16_color_FFFFFF_t_70][] 认证流程

> 1.  用户提交用户名、密码被SecurityFilterChain中的UsernamePasswordAuthenticationFilter过滤器获取到，封装为请求Authentication，通常情况下是UsernamePasswordAuthenticationToken这个实现类。
> 2.  然后过滤器将Authentication提交至认证管理器（AuthenticationManager）进行认证
> 3.  认证成功后， AuthenticationManager身份管理器返回一个被填充满了信息的（包括上面提到的权限信息，身份信息，细节信息，但密码通常会被移除） Authentication实例
> 4.  SecurityContextHolder安全上下文容器将第3步填充了信息的 Authentication ，通过SecurityContextHolder.getContext().setAuthentication(…)方法，设置到其中；可以看出**AuthenticationManager**接口（认证管理器）是认证相关的核心接口，也是发起认证的出发点，它的实现类为**ProviderManager**；而Spring Security支持多种认证方式，因此ProviderManager维护着一个List<AuthenticationProvider> 列表，存放多种认证方式，最终实际的认证工作是由**AuthenticationProvider**完成的；咱们知道web表单的对应的AuthenticationProvider实现类为**DaoAuthenticationProvider**，它的内部又维护着一个UserDetailsService负责UserDetails的获取；最终AuthenticationProvider将UserDetails填充至Authentication

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNzk0OTcz_size_16_color_FFFFFF_t_70 1][]

//org.springframework.security.web.authentication.AbstractAuthenticationProcessingFilter#doFilter
    public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) {
    	//...
        Authentication authResult;
        try {
            //
            authResult = attemptAuthentication(request, response);
            if (authResult == null) {return;}
            //
            essionStrategy.onAuthentication(authResult, request, response);
        }
        //...
        //SecurityContextHolder中设置Authentication 
        successfulAuthentication(request, response, chain, authResult);
    }
    
    //org.springframework.security.web.authentication.AbstractAuthenticationProcessingFilter#successfulAuthentication
    protected void successfulAuthentication(HttpServletRequest request,
    		HttpServletResponse response, FilterChain chain, Authentication authResult) {
    	SecurityContextHolder.getContext().setAuthentication(authResult);
    }

//org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter#attemptAuthentication
    public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) { //打断点
    	//...
    	String username = obtainUsername(request);
    	String password = obtainPassword(request);
    	//...
    	//封装Authentication
    	UsernamePasswordAuthenticationToken authRequest = new UsernamePasswordAuthenticationToken(username, password);
    	//...
    	//AuthenticationManager
    	return this.getAuthenticationManager().authenticate(authRequest);
    }

> 认证

![20200416193151191.png][]

//public class DaoAuthenticationProvider extends AbstractUserDetailsAuthenticationProvider
    
    //org.springframework.security.authentication.dao.AbstractUserDetailsAuthenticationProvider#authenticate
    public Authentication authenticate(Authentication authentication) {
        UserDetails user = this.userCache.getUserFromCache(username); 
        if (user == null) { //缓存没有
            cacheWasUsed = false;
            try {
                //查询数据库 打断点
                user = retrieveUser(username, (UsernamePasswordAuthenticationToken) authentication); 
            }
        }
        try {
            preAuthenticationChecks.check(user);
            //比对密码  打断点
            additionalAuthenticationChecks(user, (UsernamePasswordAuthenticationToken) authentication);
        }

//org.springframework.security.authentication.dao.DaoAuthenticationProvider#retrieveUser
    protected final UserDetails retrieveUser(String username, //打断点
    		UsernamePasswordAuthenticationToken authentication)
        //根据账号查询用户信息
        UserDetails loadedUser = this.getUserDetailsService().loadUserByUsername(username);

//org.springframework.security.authentication.dao.DaoAuthenticationProvider#additionalAuthenticationChecks
    protected void additionalAuthenticationChecks(UserDetails userDetails, UsernamePasswordAuthenticationToken authentication){
    	//
    	String presentedPassword = authentication.getCredentials().toString();
    	if (!passwordEncoder.matches(presentedPassword, userDetails.getPassword())) { //打断点

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNzk0OTcz_size_16_color_FFFFFF_t_70 2][] 认证核心组件的大体关系

--------------------

# 2 AuthenticationProvider #

> 通过前面的Spring Security认证流程我们得知，认证管理器（AuthenticationManager）委托 AuthenticationProvider完成认证工作
> 
> AuthenticationProvider是一个接口，定义如下：

public interface AuthenticationProvider {
    	Authentication authenticate(Authentication authentication) throws AuthenticationException;
    	boolean supports(Class<?> authentication);
    }

> **authenticate**()方法定义了认证的实现过程，它的参数是一个Authentication，里面包含了登录用户所提交的用户名、密码等；而返回值也是一个Authentication，这个Authentication则是在认证成功后，将用户的权限及其他信 息重新组装后生成
> 
> Spring Security中维护着一个List<AuthenticationProvider> 列表，存放多种认证方式，不同的认证方式使用不 同的AuthenticationProvider；如使用用户名密码登录时，使用AuthenticationProvider1，短信登录时使用 AuthenticationProvider2等等这样的例子很多
> 
> 每个AuthenticationProvider需要实现**supports**()方法来表明自己支持的认证方式，如我们使用表单方式认证， 在提交请求时Spring Security会生成UsernamePasswordAuthenticationToken，它是一个Authentication，里面封装着用户提交的用户名、密码信息；而对应的，哪个AuthenticationProvider来处理它？
> 
> 我们在DaoAuthenticationProvider的基类AbstractUserDetailsAuthenticationProvider发现以下代码：

//org.springframework.security.authentication.dao.AbstractUserDetailsAuthenticationProvider#supports
    public boolean supports(Class<?> authentication) {
    	return (UsernamePasswordAuthenticationToken.class.isAssignableFrom(authentication));
    }

> 也就是说当web表单提交用户名密码时，Spring Security由DaoAuthenticationProvider处理
> 
> 最后，我们来看一下Authentication(认证信息)的结构，它是一个接口，我们之前提到的UsernamePasswordAuthenticationToken就是它的实现之一

//org.springframework.security.core.Authentication
    public interface Authentication extends Principal, Serializable {
    	Collection<? extends GrantedAuthority> getAuthorities();
    	Object getCredentials();
    	Object getDetails();
    	Object getPrincipal();
    	boolean isAuthenticated();
    	void setAuthenticated(boolean isAuthenticated) throws IllegalArgumentException;
    }

> 1.  Authentication是spring security包中的接口，直接继承自Principal类，而Principal是位于 java.security包中的；它是表示着一个抽象主体身份，任何主体都有一个名称，因此包含一个getName()方法
> 2.  getAuthorities()，权限信息列表，默认是GrantedAuthority接口的一些实现类，通常是代表权限信息的一系列字符串
> 3.  getCredentials()，凭证信息，用户输入的密码字符串，在认证过后通常会被移除，用于保障安全
> 4.  getDetails()，细节信息，web应用中的实现接口通常为 WebAuthenticationDetails，它记录了访问者的ip地址和sessionId的值。
> 5.  getPrincipal()，身份信息，大部分情况下返回的是UserDetails接口的实现类，UserDetails代表用户的详细信息，那从Authentication中取出来的UserDetails就是当前登录用户信息，它也是框架中的常用接口之一

--------------------

# 3 UserDetailsService #

## 3.1 认识UserDetailsService ##

> 现在咱们现在知道DaoAuthenticationProvider处理了web表单的认证逻辑，认证成功后既得到一个 Authentication(UsernamePasswordAuthenticationToken实现)，里面包含了身份信息（Principal）；这个身份 信息就是一个 **Object** ，大多数情况下它可以被强转为UserDetails对象
> 
> DaoAuthenticationProvider中包含了一个UserDetailsService实例，它负责根据用户名提取用户信息 UserDetails(包含密码)，而后DaoAuthenticationProvider会去对比UserDetailsService提取的用户密码与用户提交 的密码是否匹配作为认证成功的关键依据，因此可以通过将自定义的 **UserDetailsService** 公开为spring bean来定义自定义身份验证

//org.springframework.security.core.userdetails.UserDetailsService
    public interface UserDetailsService {
    	UserDetails loadUserByUsername(String username) throws UsernameNotFoundException;
    }

> 很多人把DaoAuthenticationProvider和UserDetailsService的职责搞混淆，其实UserDetailsService只负责从特定 的地方（通常是数据库）加载用户信息，仅此而已；而DaoAuthenticationProvider的职责更大，它完成完整的认 证流程，同时会把UserDetails填充至Authentication
> 
> 上面一直提到UserDetails是用户信息，咱们看一下它的真面目：

//org.springframework.security.core.userdetails.UserDetails
    public interface UserDetails extends Serializable {
    	Collection<? extends GrantedAuthority> getAuthorities();
    	String getPassword();
    	String getUsername();
    	boolean isAccountNonExpired();
    	boolean isAccountNonLocked();
    	boolean isCredentialsNonExpired();
    	boolean isEnabled();
    }

> 它和Authentication接口很类似，比如它们都拥有username，authorities；Authentication的getCredentials()与 UserDetails中的getPassword()需要被区分对待，前者是用户提交的密码凭证，后者是用户实际存储的密码，认证 其实就是对这两者的比对；Authentication中的getAuthorities()实际是由UserDetails的getAuthorities()传递而形 成的；还记得Authentication接口中的getDetails()方法吗？其中的UserDetails用户详细信息便是经过了 AuthenticationProvider认证之后被填充的
> 
> 通过实现UserDetailsService和UserDetails，我们可以完成对用户信息获取方式以及用户信息字段的扩展
> 
> Spring Security提供的InMemoryUserDetailsManager(内存认证)，JdbcUserDetailsManager(jdbc认证)就是 UserDetailsService的实现类，主要区别无非就是从内存还是从数据库加载用户

--------------------

# 4 PasswordEncoder #

## 4.1 认识PasswordEncoder ##

> DaoAuthenticationProvider认证处理器通过UserDetailsService获取到UserDetails后，它是如何与请求 Authentication中的密码做对比呢？
> 
> 在这里Spring Security为了适应多种多样的加密类型，又做了抽象，DaoAuthenticationProvider通过 PasswordEncoder接口的matches方法进行密码的对比，而具体的密码对比细节取决于实现：

//org.springframework.security.crypto.password.PasswordEncoder
    public interface PasswordEncoder {
    	String encode(CharSequence rawPassword);
    	boolean matches(CharSequence rawPassword, String encodedPassword);
    	default boolean upgradeEncoding(String encodedPassword) {
    		return false;
    	}
    }

> 而Spring Security提供很多内置的PasswordEncoder，能够开箱即用，使用某种PasswordEncoder只需要进行如 下声明即可，如下：

@Bean
    public PasswordEncoder passwordEncoder() {
        return NoOpPasswordEncoder.getInstance();
    }

> NoOpPasswordEncoder采用字符串匹配方法，不对密码进行加密比较处理，密码比较流程如下：
> 
> 1.  用户输入密码（明文 ）
> 2.  DaoAuthenticationProvider获取UserDetails（其中存储了用户的正确密码）
> 3.  DaoAuthenticationProvider使用PasswordEncoder对输入的密码和正确的密码进行校验，密码一致则校验通 过，否则校验失败
> 
> NoOpPasswordEncoder的校验规则拿 输入的密码和UserDetails中的正确密码进行字符串比较，字符串内容一致 则校验通过，否则 校验失败

> 实际项目中推荐使用BCryptPasswordEncoder, Pbkdf2PasswordEncoder, SCryptPasswordEncoder等，感兴趣 的大家可以看看这些PasswordEncoder的具体实现。

## 4.2 使用BCryptPasswordEncoder ##

> 配置BCryptPasswordEncoder（在安全配置类中定义）

@Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

> 密码格式不对会报错：Encoded password does not look like BCrypt

//org.springframework.security.authentication.dao.DaoAuthenticationProvider#additionalAuthenticationChecks
    protected void additionalAuthenticationChecks(UserDetails userDetails, UsernamePasswordAuthenticationToken authentication) throws AuthenticationException {
    	if (authentication.getCredentials() == null) {
    		//
    	}
    	String presentedPassword = authentication.getCredentials().toString();
    	//passwordEncoder
    	if (!passwordEncoder.matches(presentedPassword, userDetails.getPassword())) {

@Test
    public void testBCrypt(){
        //对密码进行加密
        String hashpw = BCrypt.hashpw("123456", BCrypt.gensalt());
        System.out.println(hashpw);
        //校验密码
        boolean checkpw = BCrypt.checkpw("123456", "$2a$10$lVFG0yY/LsonTXN9dV/czOdIbiwbu9g7Mjno0mqDFRXy5b2k0TGUu");
        System.out.println(checkpw);
    }

[https_yuanyu.blog.csdn.net_article_details_105469059]: https://yuanyu.blog.csdn.net/article/details/105469059
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNzk0OTcz_size_16_color_FFFFFF_t_70]: /images/20230528/c3a8e909bac349eba1cfacdf40ea2e2d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNzk0OTcz_size_16_color_FFFFFF_t_70 1]: /images/20230528/70dfc941f1d746f4acadead27b45c542.png
[20200416193151191.png]: /images/20230528/5add0f05c7994761ab173fdd307218c0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNzk0OTcz_size_16_color_FFFFFF_t_70 2]: /images/20230528/74b03c4f29814177990fd620982f6655.png