大白话详解Spring Security认证流程

Young丶

已于 2023-10-20 17:13:09 修改

阅读量2.7k

点赞数 6

于 2020-11-04 10:35:26 首次发布

本文链接：https://blog.csdn.net/agonie201218/article/details/109485628

版权

spring boot 同时被 2 个专栏收录

222 篇文章 24 订阅

订阅专栏

Spring Security

24 篇文章 12 订阅

订阅专栏

前言

Spring Seuciry相关的内容看了实在是太多了，但总觉得还是理解地不够巩固，还是需要靠知识输出做巩固。

SpringSecurity 认证流程原理浅析

SpringSecurity本质是用一个Filter链实现认证的功能，利用过滤器过滤需要认证的 Request，然后进行认证。然而 SpringSecurity 并不是直接把所有 Filter 直接注册到服务容器（比如 Tomcat）上。而是使用了一个DelegatingFilterProxy 的 Filter 代理类。

使用代理的好处是：

一方面可以让 Security 的 Filter 交给 spring 管理，进而 spring 的一些功能（Filter 注册肯定要在 Listener 调用前完成，而 spring 是通过ContextLoaderListener 加载 Bean 的，使用代理的话可以延迟加载，才不会在 spring ioc 没加载前使用它）。
另外一方面，可以将 Spring 的 Filter 和其他 Filter 隔离开来。

由于DelegatingFilterProxy 是一个普通 Filter，如果通过延迟加载所有 Filter 那也太麻烦了，而且不好弄，如果让一个注册到 spring 中的代理去操作具体的 Filter，而DelegatingFilterProxy 就只需要延迟加载这个代理（直接写死在配置文件中，通过读取配置 security 的 web 配置文件，然后从 server 中拿）。而这个被用来代理处理具体和 spring 交互的就是 FilterChainProxy 。FilterChainProxy 杂负责拿到 SecurityFilterChain，并负责调用。

servlet filter 注入一个 DelegatingFilterProxy 代理过滤器该对象实例中是对 FilterChainProxy(bean name: springSecurityFilterChain ) 对象的代理
具体的流程如下所示：

FilterChainProxy 通过执行内部的过滤方法（doFilterInternal）使用了我们配置或者默认的 filter 交给 VirtualFilterChain 来执行。

在这里插入图片描述
FilterChainProxy 的 filterChains 属性包含了一组对全部 url 生效的 filters (当然也可以配置成多个不同的url，做到多系统隔离)

在这里插入图片描述

过滤器链和认证过程

讲完了如何进入 FilterChainProxy ，下面来讲讲 FilterChain 执行流程

一个认证过程，其实就是过滤器链上的一个绿色矩形Filter所要执行的过程。

基本的认证过程有三步骤：

Filter拦截请求，生成一个未认证的Authentication，交由AuthenticationManager进行认证；
AuthenticationManager的默认实现ProviderManager会通过AuthenticationProvider对Authentication进行认证，其本身不做认证处理；
如果认证通过，则创建一个认证通过的Authentication返回；否则抛出异常，以表示认证不通过。

要理解这个过程，可以从类UsernamePasswordAuthenticationFilter，ProviderManager，DaoAuthenticationProvider和InMemoryUserDetailsManager（UserDetailsService实现类，由UserDetailsServiceAutoConfiguration默认配置提供）进行了解。只要创建一个含有spring-boot-starter-security的springboot项目，在适当地打上断点接口看到这个流程。

用认证部门进行讲解

Authentication Flow to Company Flow )

请求到前台之后，负责该请求的前台会将请求的内容封装为一个Authentication对象交给认证管理部门，认证管理部门仅管理认证部门，不做具体的认证操作，具体的操作由与该前台相关的认证部门进行处理。当然，每个认证部门需要判断Authentication是否为该部门负责，是则由该部门负责处理，否则交给下一个部门处理。认证部门认证成功之后会创建一个认证通过的Authentication返回。否则要么抛出异常表示认证不通过，要么交给下一个部门处理。

如果需要新增认证类型，只要增加相应的前台(Filter)和与该前台(Filter)想对应的认证部门(AuthenticationProvider)就即可，当然也可以增加一个与已有前台对应的认证部门。认证部门会通过前台生成的Authentication来判断该认证是否由该部门负责，因而也许提供一个两者相互认同的Authentication.

认证部门需要人员资料时，则可以从人员资料部门获取。不同的系统有不同的人员资料部门，需要我们提供该人员资料部门，否则将拿到空白档案。当然，人员资料部门不一定是唯一的，认证部门可以有自己的专属资料部门。

上图还可以有如下的画法：

这个画法可能会和FilterChain更加符合。每一个前台其实就是FilterChain中的一个，客户拿着请求逐个前台请求认证，找到正确的前台之后进行认证判断。

前台（Filter）

这里的前台Filter仅仅指实现认证的Filter，Spring Security Filter Chain中处理这些Filter还有其他的Filter，比如CsrfFilter。如果非要给角色给他们，那么就当他们是保安人员吧。

Spring Security为我们提供了3个已经实现的Filter。UsernamePasswordAuthenticationFilter，BasicAuthenticationFilter和 RememberMeAuthenticationFilter。如果不做任何个性化的配置，UsernamePasswordAuthenticationFilter和BasicAuthenticationFilter会在默认的过滤器链中。这两种认证方式也就是默认的认证方式。

UsernamePasswordAuthenticationFilter仅仅会对/login路径生效，也就是说UsernamePasswordAuthenticationFilter负责发布认证，发布认证的接口为/login。

public class UsernamePasswordAuthenticationFilter extends
    AbstractAuthenticationProcessingFilter {
  ...
  public UsernamePasswordAuthenticationFilter() {
    super(new AntPathRequestMatcher("/login", "POST"));
  }
  ...
}

UsernamePasswordAuthenticationFilter为抽象类AbstractAuthenticationProcessingFilter的一个实现，而BasicAuthenticationFilter为抽象类BasicAuthenticationFilter的一个实现。这四个类的源码提供了不错的前台(Filter)实现思路。

AbstractAuthenticationProcessingFilter

AbstractAuthenticationProcessingFilter 提供了认证前后需要做的事情，其子类只需要提供实现完成认证的抽象方法attemptAuthentication(HttpServletRequest, HttpServletResponse)即可。使用AbstractAuthenticationProcessingFilter时，需要提供一个拦截路径（使用AntPathMatcher进行匹配）来拦截对应的特定的路径。

UsernamePasswordAuthenticationFilter

UsernamePasswordAuthenticationFilter作为实际的前台，会将客户端提交的username和password封装成一个UsernamePasswordAuthenticationToken交给认证管理部门(AuthenticationManager)进行认证。如此，她的任务就完成了。

BasicAuthenticationFilter

该前台(Filter)只会处理含有Authorization的Header，且小写化后的值以basic开头的请求，否则该前台(Filter)不负责处理。该Filter会从header中获取Base64编码之后的username和password，创建UsernamePasswordAuthenticationToken提供给认证管理部门(AuthenticationMananager)进行认证。

认证资料（Authentication）

前台接到请求之后，会从请求中获取所需的信息，创建自家认证部门(AuthenticationProvider)所认识的认证资料(Authentication)，认证部门(AuthenticationProvider)则主要是通过认证资料(Authentication)的类型判断是否由该部门处理。

public interface Authentication extends Principal, Serializable {
  
  // 该principal具有的权限。AuthorityUtils工具类提供了一些方便的方法。
  Collection<? extends GrantedAuthority> getAuthorities();
  // 证明Principal的身份的证书，比如密码。
  Object getCredentials();
  // authentication request的附加信息，比如ip。
  Object getDetails();
  // 当事人。在username+password模式中为username，在有userDetails之后可以为userDetails。
  Object getPrincipal();
  // 是否已经通过认证。
  boolean isAuthenticated();
  // 设置通过认证。
  void setAuthenticated(boolean isAuthenticated) throws IllegalArgumentException;
}

在Authentication被认证之后，会保存到一个thread-local的SecurityContext中。

// 设置
SecurityContextHolder.getContext().setAuthentication(anAuthentication);
// 获取
Authentication existingAuth = SecurityContextHolder.getContext()
        .getAuthentication();

在写前台Filter的时候，可以先检查SecurityContextHolder.getContext()中是否已经存在通过认证的Authentication了，如果存在，则可以直接跳过该Filter。已经通过验证的Authentication建议设置为一个不可修改的实例。

目前从Authentication的类图中看到的实现类，均为Authentication的抽象子类AbstractAuthenticationToken的实现类。实现类有好几个，与前面的讲到的Filter相关的有UsernamePasswordAuthenticationToken和RememberMeAuthenticationToken。

AbstractAuthenticationToken为CredentialsContainer和Authentication的子类。实现了一些简单的方法，但主要的方法还需要实现。该类的getName()方法的实现可以看到常用的principal类为UserDetails、AuthenticationPrincipal和Princial。如果有需要将对象设置为principal，可以考虑继承这三个类中的一个。

public String getName() {
  if (this.getPrincipal() instanceof UserDetails) {
    return ((UserDetails) this.getPrincipal()).getUsername();
  }
  if (this.getPrincipal() instanceof AuthenticatedPrincipal) {
    return ((AuthenticatedPrincipal) this.getPrincipal()).getName();
  }
  if (this.getPrincipal() instanceof Principal) {
    return ((Principal) this.getPrincipal()).getName();
  }

  return (this.getPrincipal() == null) ? "" : this.getPrincipal().toString();
}

认证管理部门(AuthenticationManager)

AuthenticationManager是一个接口，认证Authentication，如果认证通过之后，返回的Authentication应该带上该principal所具有的GrantedAuthority。

public interface AuthenticationManager {
  Authentication authenticate(Authentication authentication)
      throws AuthenticationException;
}

该接口的注释中说明，必须按照如下的异常顺序进行检查和抛出：

DisabledException：账号不可用
LockedException：账号被锁
BadCredentialsException：证书不正确

Spring Security提供一个默认的实现ProviderManager。认证管理部门(ProviderManager)仅执行管理职能，具体的认证职能由认证部门(AuthenticationProvider)执行。

public class ProviderManager implements AuthenticationManager, MessageSourceAware,
    InitializingBean {
  ...

  public ProviderManager(List<AuthenticationProvider> providers) {
    this(providers, null);
  }

  public ProviderManager(List<AuthenticationProvider> providers,
      AuthenticationManager parent) {
    Assert.notNull(providers, "providers list cannot be null");
    this.providers = providers;
    this.parent = parent;
    checkState();
  }

  public Authentication authenticate(Authentication authentication)
      throws AuthenticationException {
    Class<? extends Authentication> toTest = authentication.getClass();
    AuthenticationException lastException = null;
    AuthenticationException parentException = null;
    Authentication result = null;
    Authentication parentResult = null;
    boolean debug = logger.isDebugEnabled();

    for (AuthenticationProvider provider : getProviders()) {
      // #1, 检查是否由该认证部门进行认证`AuthenticationProvider`
      if (!provider.supports(toTest)) {
        continue;
      }

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

      try {
        // #2, 认证部门进行认证
        result = provider.authenticate(authentication);

        if (result != null) {
          copyDetails(authentication, result);
          // #3，认证通过则不再进行下一个认证部门的认证，否则抛出的异常被捕获，执行下一个认证部门(AuthenticationProvider)
          break;
        }
      }
      catch (AccountStatusException e) {
        prepareException(e, authentication);
        // SEC-546: Avoid polling additional providers if auth failure is due to
        // invalid account status
        throw e;
      }
      catch (InternalAuthenticationServiceException e) {
        prepareException(e, authentication);
        throw e;
      }
      catch (AuthenticationException e) {
        lastException = e;
      }
    }

    if (result == null && parent != null) {
      // Allow the parent to try.
      try {
        result = parentResult = parent.authenticate(authentication);
      }
      catch (ProviderNotFoundException e) {
        // ignore as we will throw below if no other exception occurred prior to
        // calling parent and the parent
        // may throw ProviderNotFound even though a provider in the child already
        // handled the request
      }
      catch (AuthenticationException e) {
        lastException = parentException = e;
      }
    }
    // #4, 如果认证通过，执行认证通过之后的操作
    if (result != null) {
      if (eraseCredentialsAfterAuthentication
          && (result instanceof CredentialsContainer)) {
        // Authentication is complete. Remove credentials and other secret data
        // from authentication
        ((CredentialsContainer) result).eraseCredentials();
      }

      // If the parent AuthenticationManager was attempted and successful than it will publish an AuthenticationSuccessEvent
      // This check prevents a duplicate AuthenticationSuccessEvent if the parent AuthenticationManager already published it
      if (parentResult == null) {
        eventPublisher.publishAuthenticationSuccess(result);
      }
      return result;
    }

    // Parent was null, or didn't authenticate (or throw an exception).
    // #5，如果认证不通过，必然有抛出异常，否则表示没有配置相应的认证部门(AuthenticationProvider)
    if (lastException == null) {
      lastException = new ProviderNotFoundException(messages.getMessage(
          "ProviderManager.providerNotFound",
          new Object[] { toTest.getName() },
          "No AuthenticationProvider found for {0}"));
    }

    // If the parent AuthenticationManager was attempted and failed than it will publish an AbstractAuthenticationFailureEvent
    // This check prevents a duplicate AbstractAuthenticationFailureEvent if the parent AuthenticationManager already published it
    if (parentException == null) {
      prepareException(lastException, authentication);
    }

    throw lastException;
  }
  ...
}

遍历所有的认证部门(AuthenticationProvider)，找到支持的认证部门进行认证认证部门进行认证认证通过则不再进行下一个认证部门的认证，否则抛出的异常被捕获，执行下一个认证部门(AuthenticationProvider)如果认证通过，执行认证通过之后的操作如果认证不通过，必然有抛出异常，否则表示没有配置相应的认证部门(AuthenticationProvider)

当使用到Spring Security OAuth2的时候，会看到另一个实现OAuth2AuthenticationManager。

认证部门(AuthenticationProvider)

认证部门(AuthenticationProvider)负责实际的认证工作，与认证管理部门(ProvderManager)协同工作。也许其他的认证管理部门(AuthenticationManager)并不需要认证部门(AuthenticationProvider)的协作。

public interface AuthenticationProvider {
  // 进行认证
  Authentication authenticate(Authentication authentication)
      throws AuthenticationException;
  // 是否由该AuthenticationProvider进行认证
  boolean supports(Class<?> authentication);
}

该接口有很多的实现类，其中包含了RememberMeAuthenticationProvider（直接AuthenticationProvider）和DaoAuthenticationProvider（通过AbastractUserDetailsAuthenticationProvider简介继承）。这里重点讲讲AbastractUserDetailsAuthenticationProvider和DaoAuthenticationProvider。

AbastractUserDetailsAuthenticationProvider

顾名思义，AbastractUserDetailsAuthenticationProvider是对UserDetails支持的Provider，其他的Provider，如RememberMeAuthenticationProvider就不需要用到UserDetails。该抽象类有两个抽象方法需要实现类完成：

// 获取 UserDetails
protected abstract UserDetails retrieveUser(String username,
    UsernamePasswordAuthenticationToken authentication)
    throws AuthenticationException;
 
protected abstract void additionalAuthenticationChecks(UserDetails userDetails,
    UsernamePasswordAuthenticationToken authentication)
    throws AuthenticationException;

retrieveUser()方法为校验提供UserDetails。先看下UserDetails：

public interface UserDetails extends Serializable {
  
  Collection<? extends GrantedAuthority> getAuthorities();

  String getPassword();
  
  String getUsername();
  // 账号是否过期
  boolean isAccountNonExpired();
  // 账号是否被锁
  boolean isAccountNonLocked();
  // 证书(password)是否过期
  boolean isCredentialsNonExpired();
  // 账号是否可用
  boolean isEnabled();
}

AbastractUserDetailsAuthenticationProvider#authentication(Authentication)分为三步验证：

preAuthenticationChecks.check(user);
additionalAuthenticationChecks(user,
(UsernamePasswordAuthenticationToken) authentication);
postAuthenticationChecks.check(user);

preAuthenticationChecks的默认实现为DefaultPreAuthenticationChecks，负责完成校验：

UserDetails#isAccountNonLocked()
UserDetails#isEnabled()
UserDetails#isAccountNonExpired()

postAuthenticationChecks的默认实现为DefaultPostAuthenticationChecks，负责完成校验：

UserDetails#user.isCredentialsNonExpired()

additionalAuthenticationChecks需要由实现类完成。

校验成功之后，AbstractUserDetailsAuthenticationProvider会创建并返回一个通过认证的Authentication。

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

DaoAuthenticationProvider

如下为DaoAuthenticationProvider对AbstractUserDetailsAuthenticationProvider抽象方法的实现。

// 检查密码是否正确
protected void additionalAuthenticationChecks(UserDetails userDetails,
    UsernamePasswordAuthenticationToken authentication)
    throws AuthenticationException {
  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"));
  }
}
// 通过资料室(UserDetailsService)获取UserDetails对象
protected final UserDetails retrieveUser(String username,
    UsernamePasswordAuthenticationToken authentication)
    throws AuthenticationException {
  prepareTimingAttackProtection();
  try {
    UserDetails loadedUser = this.getUserDetailsService().loadUserByUsername(username);
    if (loadedUser == null) {
      throw new InternalAuthenticationServiceException(
          "UserDetailsService returned null, which is an interface contract violation");
    }
    return loadedUser;
  }
  ...
}

在以上的代码中，需要提供UserDetailsService和PasswordEncoder实例。只要实例化这两个类，并放入到Spring容器中即可。

资料部门(UserDetailsService)

UserDetailsService接口提供认证过程所需的UserDetails的类，如DaoAuthenticationProvider需要一个UserDetailsService实例。

public interface UserDetailsService {
  UserDetails loadUserByUsername(String username) throws UsernameNotFoundException;
}

Spring Security提供了两个UserDetailsService的实现：InMemoryUserDetailsManager和JdbcUserDetailsManager。InMemoryUserDetailsManager为默认配置，从UserDetailsServiceAutoConfiguration的配置中可以看出。当然也不容易理解，基于数据库的实现需要增加数据库的配置，不适合做默认实现。这两个类均为UserDetailsManager的实现类，UserDetailsManager定义了UserDetails的CRUD操作。InMemoryUserDetailsManager使用Map<String, MutableUserDetails>做存储。

public interface UserDetailsManager extends UserDetailsService {
  void createUser(UserDetails user);

  void updateUser(UserDetails user);

  void deleteUser(String username);

  void changePassword(String oldPassword, String newPassword);

  boolean userExists(String username);
}

如果我们需要增加一个UserDetailsService，可以考虑实现UserDetailsService或者UserDetailsManager。

增加一个认证流程

到这里，我们已经知道Spring Security的流程了。从上面的内容可以知道，如要增加一个新的认证方式，只要增加一个[前台(Filter) + 认证部门(AuthenticationProvider) + 资料室(UserDetailsService)]组合即可。事实上，资料室(UserDetailsService)不是必须的，可根据认证部门(AuthenticationProvider)需要实现。