Spring Security OAuth专题学习-资源服务源码解读

桃扇骨 2022-02-01 09:51 283阅读 0赞

通过Spring Security OAuth专题学习的前面四篇文章（[Spring Security OAuth专题学习][Spring Security OAuth]），对于Spring Security OAUth的基本使用已经有了一些基本的概念。  
然而对于资源服务及授权服务生效原理，仍旧一无所知。接下来将从源码层面对Spring Security OAuth相关组件进行分析与学习。

Spring Security OAuth中，资源服务主要完成两个核心功能：一是调用授权服务的接口完成Token有效性验证； 二是调用Spring Security的拦截器完成权限充分性  
验证（如当前用户是否具有当前请求所需要的权限）。Token有效性检查由其所引入的Filter来完成验证； 而权限充分性验证由标准Spring Security的功能完成。

主处理流程如下：

Created with Raphaël 2.2.0开始Token检查Token有效?权限足够？业务处理End抛出异常yesnoyesno

下面来进行具体分析。

# 0. 配置： #

通过专题前面系列的文章，可以知道资源服务器相对于普通应用来说主要有两处需要配置：

*  通过EnableResourceServer启用资源服务；
 *  通过ResourceServerConfigurer完成对资源服务的相关配置；

> 下文中，统一将实现ResourceServerConfigurer接口的类称为用户自定义的资源服务器配置类，简称用户自定义配置类；以与ResourceServerSecurityConfigurer  
> 区分； 后者是资源与Security关联的配置信息集合，在下文中简称资源服务配置类，具体说明见后文。

# 1. 入口：EnableResourceServer #

资源服务应用需要使用EnableResourceServer注解来完成相关配置的引入。

定义如下：

@Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Import(ResourceServerConfiguration.class)
    public @interface EnableResourceServer { 
    
    }

它所做的事情，就是引入了一个WebSecurityConfigurerAdapter的子类（ResourceServerConfiguration），通过这个配置类来完成资源及请求授权控制相关配置。

> WebSecurityConfigurerAdapter是标准Spring Security的一个对Spring Security Filter进行配置的类，可用于配置对请求路径的授权等。  
> Spring Security中，关于Configuration有两类类，一类是\*\* Configurer这种叫法的，一种是\*\* Configuration这种叫法的；前者一般是对某一对象进行配置的类，如对WebSecurity或者是HttpSecurity对象进行配置；后者指一些配置项的集合或者入口。

# 2. ResourceServerConfiguration #

定义如下：

@Configuration
    public class ResourceServerConfiguration extends WebSecurityConfigurerAdapter implements Ordered

它继承自WebSecurityConfigurerAdapter，而这个类正好是标准Spring Security中的配置抽象类！Resource Server通过它与Spring Security实现关联。

ResourceServerConfiguration中主要方法是configure方法，处理流程如下：

Created with Raphaël 2.2.0开始创建资源服务配置类配置TokenService配置TokenStore通过用户自定义配置类完成资源配置将资源配置类添加到httpSecurity对象通过用户定义配置类完成httpSecurity对象配置结束

*  创建资源配置类：资源配置类为ResourceServerSecurityConfigurer，通过它可完成资源服务器所使用的tokenService及tokenStore、authenticationManager等配置。
 *  通过用户配置类完成资源配置：从应用中查找所有实现ResourceServerConfigurer的类，调用这些类的configure方法，对第一步创建的资源配置类进行用户自定义配置。
 *  将资源配置类添加到httpSecurity对象：调用http.apply方法，将资源配置类添加到httpSecurity的配置类清单中，最终在构建Spring标准Filter的时候会使用到。
 *  通过用户定义配置类完成httpSecurity对象配置：从应用中查找所有实现ResourceServerConfigurer接口的类，调用configure方法，对httpSecurity进行用户自定义配置。

具体实现如下：

@Override
    	protected void configure(HttpSecurity http) throws Exception { 
    		ResourceServerSecurityConfigurer resources = new ResourceServerSecurityConfigurer();
    		ResourceServerTokenServices services = resolveTokenServices();
    		if (services != null) { 
    			resources.tokenServices(services);
    		}
    		else { 
    			if (tokenStore != null) { 
    				resources.tokenStore(tokenStore);
    			}
    			else if (endpoints != null) { 
    				resources.tokenStore(endpoints.getEndpointsConfigurer().getTokenStore());
    			}
    		}
    		if (eventPublisher != null) { 
    			resources.eventPublisher(eventPublisher);
    		}
    		for (ResourceServerConfigurer configurer : configurers) { 
    			configurer.configure(resources);
    		}
    		// @formatter:off
    		http.authenticationProvider(new AnonymousAuthenticationProvider("default"))
    		// N.B. exceptionHandling is duplicated in resources.configure() so that
    		// it works
    		.exceptionHandling()
    				.accessDeniedHandler(resources.getAccessDeniedHandler()).and()
    				.sessionManagement()
    				.sessionCreationPolicy(SessionCreationPolicy.STATELESS).and()
    				.csrf().disable();
    		// @formatter:on
    		http.apply(resources);
    		if (endpoints != null) { 
    			// Assume we are in an Authorization Server
    			http.requestMatcher(new NotOAuthRequestMatcher(endpoints.oauth2EndpointHandlerMapping()));
    		}
    		for (ResourceServerConfigurer configurer : configurers) { 
    			// Delegates can add authorizeRequests() here
    			configurer.configure(http);
    		}
    		if (configurers.isEmpty()) { 
    			// Add anyRequest() last as a fall back. Spring Security would
    			// replace an existing anyRequest() matcher with this one, so to
    			// avoid that we only add it if the user hasn't configured anything.
    			http.authorizeRequests().anyRequest().authenticated();
    		}
    	}

# 3. ResourceServerConfigurer #

在上一节中，提到一些实现了ResourceServerConfigurer接口的用户自定义配置类，它通过其configure方法，完成对资源服务配置类（ResourceServerSecurityConfigurer）  
及httpSecurity的用户自定义配置，接口定义如下：

public interface ResourceServerConfigurer { 
    	void configure(ResourceServerSecurityConfigurer resources) throws Exception;
    	void configure(HttpSecurity http) throws Exception;
    }

当用户在应用中定义类实现该接口时，在上一节所说的ResourceServerConfiguration类的configure方法中，即会调用用户所定义的过程来完成相关配置。这个接口的实现示例如下：

@Configuration
    @EnableGlobalMethodSecurity(prePostEnabled = true)
    public class SecurityConfigurer extends ResourceServerConfigurerAdapter { 
        @Autowired
        private RealAuthenticationProvider authenticationProvider;
    
        @Resource
        private AppVoter appVoter;
    
        @Resource
        private MyCorsFilter myCorsFilter;
    
        @Override
        public void configure(ResourceServerSecurityConfigurer resources) throws Exception { 
            resources.resourceId("testResource")
                    .stateless(true);
        }
    
        @Override
        public void configure(HttpSecurity http) throws Exception { 
            http
                    .authorizeRequests()
                        .antMatchers(HttpMethod.OPTIONS, "**").permitAll()
                        .antMatchers("/*", "/css/**/*", "/js/**/*", "/icons/**/*", "/upload/*",
                                "/h2-console/", "/h2-console/**/*", "/topic/**/*").permitAll()
                        .anyRequest().authenticated()
                    .and()
                    .formLogin()
                        .loginPage("/login")
                        .loginProcessingUrl("/iLogin")
                        .permitAll()
                    .and().logout().logoutUrl("/logout").logoutSuccessUrl("/")
    // .and().sessionManagement().invalidSessionUrl("/timeout")
                    .and().cors();
            http.headers().frameOptions().sameOrigin().httpStrictTransportSecurity().disable();
            http.authorizeRequests().withObjectPostProcessor(new ObjectPostProcessor<AffirmativeBased>() { 
                @Override
                public <O extends AffirmativeBased> O postProcess(O object) { 
                    object.getDecisionVoters().add(appVoter);
                    return object;
                }
            });
    
            http.addFilterBefore(myCorsFilter, WebAsyncManagerIntegrationFilter.class);
        }
    
        @Bean
        public static NoOpPasswordEncoder passwordEncoder() { 
            return (NoOpPasswordEncoder) NoOpPasswordEncoder.getInstance();
        }
    
        @Autowired
        public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception { 
            auth.authenticationProvider(authenticationProvider);
        }
    }

在这个示例中，通过configure(ResourceServerSecurityConfigurer resources)方法，指定了资源服务所包含的资源编号信息；  
同时也可以通过configure(HttpSecurity http)方法来完成对标准Spring Security的相关配置。一般情况下，  
可以仅实现configure(ResourceServerSecurityConfigurer resources)方法。

# 4. ResourceServerSecurityConfigurer #

在上文中有提到ResourceServerSecurityConfigurer配置类，它用于完成对资源服务的相关配置，主要包括以下配置项：

*  TokenStore: Token存储方式；
 *  TokenService: Token生成及校验服务；
 *  authenticationManager: 授权服务；
 *  resourceId: 资源编号；
 *  tokenExtractor：Token解析器；
 *  其它

这个类实现了SecurityConfigurer接口，在上文中，提到会httpSecurity.apply(ResourceServerSecurityConfigurer)方法将其添加到httpSecurity的配置类中去；  
我们先来看下apply方法：

public <C extends SecurityConfigurerAdapter<O, B>> C apply(C configurer)
    			throws Exception { 
    		configurer.addObjectPostProcessor(objectPostProcessor);
    		configurer.setBuilder((B) this);
    		add(configurer);
    		return configurer;
    	}

再看add方法(为简化省略无关代码)：

private <C extends SecurityConfigurer<O, B>> void add(C configurer) throws Exception { 
    		Assert.notNull(configurer, "configurer cannot be null");
    
    		Class<? extends SecurityConfigurer<O, B>> clazz = (Class<? extends SecurityConfigurer<O, B>>) configurer
    				.getClass();
    		synchronized (configurers) { 
    			...
    			configs.add(configurer);
    			...
    		}
    	}

主要就是将ResourceServerSecurityConfigurer添加到了httpSecurity的configurer对象中去。

那么添加之后会做何处理呢？最终在HttpSecurity的doBuild方法中生效：

protected final O doBuild() throws Exception { 
    		synchronized (configurers) { 
    			buildState = BuildState.INITIALIZING;
    
    			beforeInit();
    			init();
    
    			buildState = BuildState.CONFIGURING;
    
    			beforeConfigure();
    			configure();
    
    			buildState = BuildState.BUILDING;
    
    			O result = performBuild();
    
    			buildState = BuildState.BUILT;
    
    			return result;
    		}
    	}

具体使用是在configure方法中：

private void configure() throws Exception { 
    		Collection<SecurityConfigurer<O, B>> configurers = getConfigurers();
    
    		for (SecurityConfigurer<O, B> configurer : configurers) { 
    			configurer.configure((B) this);
    		}
    	}

可见最终还是调用了ResourceServerSecurityConfigurer的configure方法。

接下来看下这个方法做了些什么事情。

其定义如下：

public void configure(HttpSecurity http) throws Exception { 
        AuthenticationManager oauthAuthenticationManager = oauthAuthenticationManager(http);
        resourcesServerFilter = new OAuth2AuthenticationProcessingFilter();
        resourcesServerFilter.setAuthenticationEntryPoint(authenticationEntryPoint);
        resourcesServerFilter.setAuthenticationManager(oauthAuthenticationManager);
        if (eventPublisher != null) { 
            resourcesServerFilter.setAuthenticationEventPublisher(eventPublisher);
        }
        if (tokenExtractor != null) { 
            resourcesServerFilter.setTokenExtractor(tokenExtractor);
        }
        if (authenticationDetailsSource != null) { 
            resourcesServerFilter.setAuthenticationDetailsSource(authenticationDetailsSource);
        }
        resourcesServerFilter = postProcess(resourcesServerFilter);
        resourcesServerFilter.setStateless(stateless);
    
        // @formatter:off
        http
            .authorizeRequests().expressionHandler(expressionHandler)
        .and()
            .addFilterBefore(resourcesServerFilter, AbstractPreAuthenticatedProcessingFilter.class)
            .exceptionHandling()
                .accessDeniedHandler(accessDeniedHandler)
                .authenticationEntryPoint(authenticationEntryPoint);
        // @formatter:on
    }

可以看到他就是构建了一个OAuth2AuthenticationProcessingFilter对象，然后添加到httpSecurity对象中去了。其中前面所配置的TokenService/TokenStore等，全部都  
被配置到这个Filter中去了。

> 到这里就很清晰了：资源服务通过一系列的配置，构建了一个Filter，然后添加到了Security的Filter清单中去了。

# 5. OAuth2AuthenticationProcessingFilter #

最后来看下这个创建的Filter，Filter中最关键的方法就是doFilter方法：

public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException,
    			ServletException { 
    
    		final boolean debug = logger.isDebugEnabled();
    		final HttpServletRequest request = (HttpServletRequest) req;
    		final HttpServletResponse response = (HttpServletResponse) res;
    
    		try { 
    
    			Authentication authentication = tokenExtractor.extract(request);
    
    			if (authentication == null) { 
    				if (stateless && isAuthenticated()) { 
    					if (debug) { 
    						logger.debug("Clearing security context.");
    					}
    					SecurityContextHolder.clearContext();
    				}
    				if (debug) { 
    					logger.debug("No token in request, will continue chain.");
    				}
    			}
    			else { 
    				request.setAttribute(OAuth2AuthenticationDetails.ACCESS_TOKEN_VALUE, authentication.getPrincipal());
    				if (authentication instanceof AbstractAuthenticationToken) { 
    					AbstractAuthenticationToken needsDetails = (AbstractAuthenticationToken) authentication;
    					needsDetails.setDetails(authenticationDetailsSource.buildDetails(request));
    				}
    				Authentication authResult = authenticationManager.authenticate(authentication);
    
    				if (debug) { 
    					logger.debug("Authentication success: " + authResult);
    				}
    
    				eventPublisher.publishAuthenticationSuccess(authResult);
    				SecurityContextHolder.getContext().setAuthentication(authResult);
    
    			}
    		}
    		catch (OAuth2Exception failed) { 
    			SecurityContextHolder.clearContext();
    
    			if (debug) { 
    				logger.debug("Authentication request failed: " + failed);
    			}
    			eventPublisher.publishAuthenticationFailure(new BadCredentialsException(failed.getMessage(), failed),
    					new PreAuthenticatedAuthenticationToken("access-token", "N/A"));
    
    			authenticationEntryPoint.commence(request, response,
    					new InsufficientAuthenticationException(failed.getMessage(), failed));
    
    			return;
    		}
    
    		chain.doFilter(request, response);
    	}

可见它就是从请求中加载Token，并对Token进行有效性检查，异常时不再调用后续的Filter。只有在没有Token或者是Token有效且有对资源有权限访问时，才会继续执行下一个Filter。

具体的Token有效性检查在OAuth2AuthenticationManager中进行：

public Authentication authenticate(Authentication authentication) throws AuthenticationException { 
    
    		if (authentication == null) { 
    			throw new InvalidTokenException("Invalid token (token not found)");
    		}
    		String token = (String) authentication.getPrincipal();
    		OAuth2Authentication auth = tokenServices.loadAuthentication(token);
    		if (auth == null) { 
    			throw new InvalidTokenException("Invalid token: " + token);
    		}
    
    		Collection<String> resourceIds = auth.getOAuth2Request().getResourceIds();
    		if (resourceId != null && resourceIds != null && !resourceIds.isEmpty() && !resourceIds.contains(resourceId)) { 
    			throw new OAuth2AccessDeniedException("Invalid token does not contain resource id (" + resourceId + ")");
    		}
    
    		checkClientDetails(auth);
    
    		if (authentication.getDetails() instanceof OAuth2AuthenticationDetails) { 
    			OAuth2AuthenticationDetails details = (OAuth2AuthenticationDetails) authentication.getDetails();
    			// Guard against a cached copy of the same details
    			if (!details.equals(auth.getDetails())) { 
    				// Preserve the authentication details from the one loaded by token services
    				details.setDecodedDetails(auth.getDetails());
    			}
    		}
    		auth.setDetails(authentication.getDetails());
    		auth.setAuthenticated(true);
    		return auth;
    
    	}

主要完成了Token的验证、资源访问权限的校验以及客户端权限的校验等事项。

# 6. 总结 #

根据上文分析，在资源服务中，主要有以下相关类：

*  EnableResourceServer
 *  ResourceServerConfiguration
 *  ResourceServerConfigurer
 *  ResourceServerSecurityConfigurer
 *  OAuth2AuthenticationProcessingFilter

前面那些类都是为最后生成的Filter服务的；其中，EnableResourceServer用于引入资源服务配置，ResourceServerConfiguration为总配置入口，  
ResourceServerConfigurer为用户自定义配置；ResourceServerSecurityConfigurer可以看成是配置项集合。

[Spring Security OAuth]: http://liumoran.cn/topic/myTopics/1