SpringBoot + Spring Security 学习笔记（二）安全认证流程源码详解

时间  2019-12-05
标签 springboot spring security 学习 笔记 安全 认证 流程 源码 详解 栏目 Spring 繁體版
原文   原文链接

用户认证流程

UsernamePasswordAuthenticationFilter

咱们直接来看UsernamePasswordAuthenticationFilter类，html

public class UsernamePasswordAuthenticationFilter extends AbstractAuthenticationProcessingFilter {
    
    public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {
        // 判断是不是 POST 请求
        if (postOnly && !request.getMethod().equals("POST")) {
            throw new AuthenticationServiceException(
                "Authentication method not supported: " + request.getMethod());
        }
        
        // 获取请求中的用户，密码。
        // 就是最简单的：request.getParameter(xxx)
        String username = obtainUsername(request);
        String password = obtainPassword(request);

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

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

        username = username.trim();

        // 生成 authRequest，本质就是个 usernamePasswordAuthenticationToken
        UsernamePasswordAuthenticationToken authRequest = new UsernamePasswordAuthenticationToken(
            username, password);

        // 把 request 请求也一同塞进 token 里
        // Allow subclasses to set the "details" property
        setDetails(request, authRequest);
        // 将 authRequest 塞进 AuthenticationManager并返回
        return this.getAuthenticationManager().authenticate(authRequest);
    }
}
复制代码

在attemptAuthentication()方法中：主要是先进行请求判断并获取username和password的值，而后再生成一个UsernamePasswordAuthenticationToken对象，将这个对象塞进AuthenticationManager对象并返回，注意：此时的authRequest的权限是没有任何值的。java

UsernamePasswordAuthenticationToken

不过咱们能够先看看UsernamePasswordAuthenticationToken的构造方法：git

public UsernamePasswordAuthenticationToken(Object principal, Object credentials) {
    super(null);
    this.principal = principal;
    this.credentials = credentials;
    setAuthenticated(false);
}
复制代码

其实UsernamePasswordAuthenticationToken是继承于Authentication，该对象在学习笔记一中的中"自定义处理登陆成功/失败"章节里的自定义登陆成功里有提到过，它是处理登陆成功回调方法中的一个参数，里面包含了用户信息、请求信息等参数。github

来一张继承关系图，对其有个大概的认识，注意到Authentication继承了Principal。spring

AuthenticationManager

AuthenticationManager是一个接口，它的全部实现类如图：api

其中一个十分核心的类就是：ProviderManager，在attemptAuthentication()方法最后返回的就是这个类缓存

this.getAuthenticationManager().authenticate(authRequest);
复制代码

进入authenticate()方法查看具体作了什么：安全

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.判断是否有provider支持该Authentication
        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);
                break;
            }
        }
        catch (AccountStatusException e) {
           ……
        }
    }

    ……
}
复制代码

这里首先经过 provider 判断是否支持当前传入进来的Authentication，目前咱们使用的是UsernamePasswordAuthenticationToken，由于除了账号密码登陆的方式，还会有其余的方式，好比JwtAuthenticationToken。服务器

从总体来看Authentication 的实现类如图：session

官方 API 文档列出了全部的子类

从总体来看AuthenticationProvider的实现类如图：

官方 API 文档列出了全部的子类

根据咱们目前所使用的UsernamePasswordAuthenticationToken，provider 对应的是AbstractUserDetailsAuthenticationProvider抽象类的子类DaoAuthenticationProvider，其authenticate()属于抽象类自己的方法。

public Authentication authenticate(Authentication authentication) throws AuthenticationException {
    Assert.isInstanceOf(UsernamePasswordAuthenticationToken.class, authentication, () -> messages.getMessage(
                            "AbstractUserDetailsAuthenticationProvider.onlySupports",
                            "Only UsernamePasswordAuthenticationToken is supported"));

    // Determine username
    String username = (authentication.getPrincipal() == null) ? "NONE_PROVIDED"
        : authentication.getName();

    boolean cacheWasUsed = true;
    // 1.从缓存中获取 UserDetails
    UserDetails user = this.userCache.getUserFromCache(username);

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

        try {
            // 2.缓存获取不到，就去接口实现类中获取
            user = retrieveUser(username,
                                (UsernamePasswordAuthenticationToken) authentication);
        }
        catch (UsernameNotFoundException notFound) {
            ……
        }

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

    try {
        // 3.用户信息预检查（用户是否密码过时，用户信息被删除等）
        preAuthenticationChecks.check(user);
        // 4.附加的检查（密码检查：匹配用户的密码和服务器中的用户密码是否一致）
        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;
        }
    }

    // 5.最后的检查
    postAuthenticationChecks.check(user);

    ……

    // 6.返回真正的通过认证的Authentication 
    return createSuccessAuthentication(principalToReturn, authentication, user);
}
复制代码

注意： retrieveUser()的具体方法实现是由DaoAuthenticationProvider类完成的：

public class DaoAuthenticationProvider extends AbstractUserDetailsAuthenticationProvider {	
	
    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;
        }
        catch (UsernameNotFoundException ex) {
            ……
        }
    }
}
复制代码

同时createSuccessAuthentication()的方法也是由DaoAuthenticationProvider类来完成的：

// 子类拿 user 对象
@Override
protected Authentication createSuccessAuthentication(Object principal, Authentication authentication, UserDetails user) {
    boolean upgradeEncoding = this.userDetailsPasswordService != null
        && this.passwordEncoder.upgradeEncoding(user.getPassword());
    if (upgradeEncoding) {
        String presentedPassword = authentication.getCredentials().toString();
        String newPassword = this.passwordEncoder.encode(presentedPassword);
        user = this.userDetailsPasswordService.updatePassword(user, newPassword);
    }
    // 调用父类的方法完成 Authentication 的建立
    return super.createSuccessAuthentication(principal, authentication, user);
}

// 建立已认证的 Authentication
protected Authentication createSuccessAuthentication(Object principal, Authentication authentication, UserDetails user) {
    UsernamePasswordAuthenticationToken result = new UsernamePasswordAuthenticationToken(
        principal, authentication.getCredentials(),
        authoritiesMapper.mapAuthorities(user.getAuthorities()));
    result.setDetails(authentication.getDetails());

    return result;
}
复制代码

小结：authenticate()的认证逻辑

  1. 去调用本身实现的UserDetailsService，返回UserDetails
  2. 对 UserDetails 的信息进行校验，主要是账号是否被冻结，是否过时等
  3. 对密码进行检查，这里调用了PasswordEncoder，检查 UserDetails 是否可用。
  4. 返回通过认证的Authentication

编码技巧提示：这里在认证以前使用了Assert.isInstanceOf()进行断言校验，方法内部也不断用了Assert.notNull()，这种编码很是的灵巧，省去了后续的类型判断。

这里的两次对UserDetails的检查，主要就是经过它的四个返回 boolean 类型的方法（isAccountNonExpired()，isAccountNonLocked()，isCredentialsNonExpired()，isEnabled()）。

通过信息的校验以后，经过UsernamePasswordAuthenticationToken的全参构造方法，返回了一个已通过认证的Authentication。

拿到通过认证的Authentication以后，至此UsernamePasswordAuthenticationFilter的过滤步骤就彻底结束了，以后就会进入BasicAuthenticationFilter，具体来讲就是去调用successHandler。或者未经过认证，去调用failureHandler。

已认证数据共享

完成了用户认证处理流程以后，咱们思考一下是如何在多个请求之间共享这个认证结果的呢？由于没有作关于这方面的配置，因此能够联想到默认的方式应该是在session中存入了认证结果。思考：那么是何时存放入session中的呢？

认证流程完毕以后，再看是谁调用的它，发现是AbstractAuthenticationProcessingFilter的doFilter()进行调用的，这是AbstractAuthenticationProcessingFilter继承关系结构图：

当认证成功以后会调用successfulAuthentication(request, response, chain, authResult)，该方法中，不只调用了successHandler，还有一行比较重要的代码：

public abstract class AbstractAuthenticationProcessingFilter extends GenericFilterBean implements ApplicationEventPublisherAware, MessageSourceAware {
    public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {
        // 调用了 UsernamePasswordAuthenticationFilter
        authResult = attemptAuthentication(request, response);
        
        ……
        // 调用方法，目的是保存到session 
        successfulAuthentication(request, response, chain, authResult);
    }

    // 将成功认证的用户信息保存到session
    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 的静态属性 SecurityContextHolderStrategy 里， 很是重要的代码
        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);
    }
}

// SecurityContextHolder类中存着 静态属性：SecurityContextHolderStrategy
public class SecurityContextHolder {
    ……
    private static SecurityContextHolderStrategy strategy;
    ……

    public static void setContext(SecurityContext context) {
        strategy.setContext(context);
    }
}
复制代码

SecurityContextHolderStrategy接口的全部实现类：

很是显眼的看出：ThreadLocalSecurityContextHolderStrategy类：

final class ThreadLocalSecurityContextHolderStrategy implements SecurityContextHolderStrategy {

    private static final ThreadLocal<SecurityContext> contextHolder = new ThreadLocal<>();

    ……

    public void setContext(SecurityContext context) {
        Assert.notNull(context, "Only non-null SecurityContext instances are permitted");
        // 将已认证的用户对象保存到 ThreadLocal<SecurityContext> 中
        contextHolder.set(context);
    }
    ……
}
复制代码

注意：SecurityContext类的equals()和hashCode()方法已经重写了，用来保证了authentication的惟一性。

身份认证成功后，最后在UsernamePasswordAuthenticationFilter返回后会进入一个AbstractAuthenticationProcessingFilter类中调用successfulAuthentication()方法，这个方法最后会返回咱们本身定义的登陆成功处理器handler。

在返回以前，它会调用SecurityContext，最后将认证的结果放入SecurityContextHolder中，SecurityContext 类很简单，重写了equals() 方法和hashCode()方法，保证了authentication的惟一性。

从代码能够看出：SecurityContextHolder类其实是对ThreadLocal的一个封装，能够在不一样方法之间进行通讯，能够简单理解为线程级别的一个全局变量。

所以，能够在同一个线程中的不一样方法中获取到认证信息。最后会被SecurityContextPersistenceFilter过滤器使用，这个过滤器的做用是：

当一个请求来的时候，它会将 session 中的值传入到该线程中，当请求返回的时候，它会判断该请求线程是否有 SecurityContext，若是有它会将其放入到 session 中，所以保证了请求结果能够在不一样的请求之间共享。

用户认证流程总结

引用徐靖峰在我的博客Spring Security(一)--Architecture Overview中的归纳性总结，很是的到位：

  1. 用户名和密码被过滤器获取到，封装成Authentication，一般状况下是UsernamePasswordAuthenticationToken这个实现类。
  2. AuthenticationManager 身份管理器负责验证这个Authentication。
  3. 认证成功后，AuthenticationManager身份管理器返回一个被填充满了信息的（包括上面提到的权限信息，身份信息，细节信息，但密码一般会被移除）Authentication实例。
  4. SecurityContextHolder安全上下文容器将第3步填充了信息的Authentication，经过SecurityContextHolder.getContext().setAuthentication(…)方法，设置到其中。

高度归纳起来本章节全部用的核心认证相关接口：SecurityContextHolder是

身份信息的存放容器，Authentication是身份信息的抽象，AuthenticationManager是身份认证器，通常经常使用的是用户名+密码的身份认证器，还有其它认证器，如邮箱+密码、手机号码+密码等。

再引用一张十分流行的流程图来表示用户的认证过程：

架构概览图

为了更加形象的理解，在徐靖峰大佬的经典架构图之上，根据本身的理解，作了更多的细化和调整：

获取认证用户信息

若是咱们须要获取用的校验过的全部信息，该如何获取呢？上面咱们知道了会将校验结果放入 session 中，所以，咱们能够经过 session 获取：

@GetMapping("/me1")
@ResponseBody
public Object getMeDetail() {
    return SecurityContextHolder.getContext().getAuthentication();
}

@GetMapping("/me2")
@ResponseBody
public Object getMeDetail(Authentication authentication){
    return authentication;
}
复制代码

在登陆成功以后，上面有两种方式来获取，访问上面的请求，就会获取用户所有的校验信息，包括ip地址等信息。

若是咱们只想获取用户名和密码以及它的权限，不须要ip地址等太多的信息可使用下面的方式来获取信息：

@GetMapping("/me3")
@ResponseBody
public Object getMeDetail(@AuthenticationPrincipal UserDetails userDetails){
    return userDetails;
}
复制代码

参考资料：

www.cnkirito.moe/spring-secu…

blog.csdn.net/u013435893/…

blog.csdn.net/qq_37142346…

我的博客：woodwhale's blog

博客园：木鲸鱼的博客

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程