SpringSecurity OAuth2：授权服务器与资源服务器配置

文章目录

• • 引言
  • 一、OAuth2基础概念与架构
  • 二、授权服务器配置
  • 三、令牌策略与存储方式
  • 四、资源服务器配置
  • 五、远程令牌验证与内省
  • 总结

引言

在现代分布式应用架构中，OAuth2已成为实现安全授权与认证的事实标准。Spring Security对OAuth2提供了全面支持，使开发者能够轻松实现标准兼容的授权服务器和资源服务器。尽管Spring Security OAuth项目已于2020年进入维护模式，由Spring Authorization Server项目接替，但其核心概念仍然适用。本文将深入探讨如何在Spring生态系统中配置OAuth2的授权服务器和资源服务器，包括客户端注册、授权类型配置、令牌管理以及资源保护策略。通过掌握这些配置要点，开发者可以构建安全、标准化的OAuth2实现，保障分布式系统中的服务和资源安全。

一、OAuth2基础概念与架构

OAuth2框架定义了四个关键角色：资源所有者（用户）、客户端应用、授权服务器和资源服务器。授权服务器负责认证用户身份并颁发访问令牌，资源服务器则负责验证令牌有效性并保护资源。Spring Security提供了实现这两类服务器的完整支持，使开发者能够以声明式方式定义OAuth2安全策略。在微服务架构中，通常一个中心化的授权服务负责整个系统的认证和授权，而多个资源服务则保护各自的API资源。理解这一架构是正确配置Spring Security OAuth2的基础。

// OAuth2核心组件关系示意图（代码表示）
public class OAuth2Architecture {

// 授权服务器职责
interface AuthorizationServer {
// 验证客户端身份
boolean authenticateClient(ClientDetails client);

// 处理授权请求
AuthorizationRequest processAuthorizationRequest(Principal user);

// 颁发访问令牌
OAuth2AccessToken issueAccessToken(AuthorizationRequest authorizationRequest);

// 刷新令牌
OAuth2AccessToken refreshAccessToken(String refreshToken);
}

// 资源服务器职责
interface ResourceServer {
// 验证访问令牌
Authentication validateToken(String accessToken);

// 检查权限
boolean checkPermission(Authentication authentication, Object resource);

// 提供受保护资源
Object provideResource(Authentication authentication);
}

// 客户端应用
interface Client {
// 获取授权码
String obtainAuthorizationCode();

// 使用授权码交换访问令牌
OAuth2AccessToken exchangeForAccessToken(String authorizationCode);

// 访问资源
Object accessResource(OAuth2AccessToken accessToken);
}
}

二、授权服务器配置

授权服务器是OAuth2架构的核心，负责认证用户、验证客户端以及颁发令牌。在Spring Security中，通过继承AuthorizationServerConfigurerAdapter类并实现其配置方法来自定义授权服务器行为。关键配置包括：客户端详情服务（定义注册的客户端）、令牌服务（控制令牌生成和存储）、授权端点（处理授权请求的URL）以及安全策略（如支持的授权类型、令牌有效期等）。虽然Spring Authorization Server项目正逐步取代原有实现，但核心配置概念保持一致。

@Configuration
@EnableAuthorizationServer
public class AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {

@Autowired
private AuthenticationManager authenticationManager;

@Autowired
private UserDetailsService userDetailsService;

@Autowired
private DataSource dataSource;

@Override
public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
// 配置客户端详情
clients.jdbc(dataSource) // 使用数据库存储客户端信息
.withClient("web-client") // 客户端ID
.secret(passwordEncoder().encode("secret")) // 客户端密钥
.authorizedGrantTypes("authorization_code", "refresh_token", "password") // 支持的授权类型
.scopes("read", "write") // 允许的作用域
.redirectUris("http://localhost:8080/callback") // 重定向URI
.accessTokenValiditySeconds(3600) // 访问令牌有效期
.refreshTokenValiditySeconds(86400) // 刷新令牌有效期
.and()
.withClient("mobile-client")
.secret(passwordEncoder().encode("mobile-secret"))
.authorizedGrantTypes("authorization_code", "password", "refresh_token")
.scopes("read")
.redirectUris("com.example.app://oauth2callback")
.accessTokenValiditySeconds(1800)
.refreshTokenValiditySeconds(43200);
}

@Override
public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
// 配置授权服务器端点
endpoints
.authenticationManager(authenticationManager) // 认证管理器
.userDetailsService(userDetailsService) // 用户详情服务
.tokenStore(tokenStore()) // 令牌存储方式
.accessTokenConverter(accessTokenConverter()) // 令牌转换器
.tokenEnhancer(tokenEnhancerChain()) // 令牌增强链
.allowedTokenEndpointRequestMethods(HttpMethod.POST) // 允许的令牌端点请求方法
.reuseRefreshTokens(false); // 刷新令牌时不复用原刷新令牌
}

@Override
public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
// 配置令牌端点的安全约束
security
.tokenKeyAccess("permitAll()") // 令牌密钥端点访问控制
.checkTokenAccess("isAuthenticated()") // 令牌检查端点访问控制
.allowFormAuthenticationForClients(); // 允许客户端使用表单认证
}

@Bean
public TokenStore tokenStore() {
// 使用JWT令牌存储
return new JwtTokenStore(accessTokenConverter());
}

@Bean
public JwtAccessTokenConverter accessTokenConverter() {
JwtAccessTokenConverter converter = new JwtAccessTokenConverter();
converter.setSigningKey("secret-key"); // 设置JWT签名密钥
return converter;
}

@Bean
public TokenEnhancerChain tokenEnhancerChain() {
// 配置令牌增强链
TokenEnhancerChain tokenEnhancerChain = new TokenEnhancerChain();
tokenEnhancerChain.setTokenEnhancers(
Arrays.asList(customTokenEnhancer(), accessTokenConverter()));
return tokenEnhancerChain;
}

@Bean
public TokenEnhancer customTokenEnhancer() {
// 自定义令牌增强器，添加额外信息到令牌
return new CustomTokenEnhancer();
}

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

// 自定义令牌增强器
class CustomTokenEnhancer implements TokenEnhancer {
@Override
public OAuth2AccessToken enhance(OAuth2AccessToken accessToken, OAuth2Authentication authentication) {
Map<String, Object> additionalInfo = new HashMap<>();

// 向令牌添加额外信息
if (authentication.getPrincipal() instanceof UserDetails) {
UserDetails user = (UserDetails) authentication.getPrincipal();
additionalInfo.put("username", user.getUsername());
// 可以添加其他用户信息
}

additionalInfo.put("organization", "example-org");
additionalInfo.put("timestamp", new Date().getTime());

((DefaultOAuth2AccessToken) accessToken).setAdditionalInformation(additionalInfo);
return accessToken;
}
}

三、令牌策略与存储方式

OAuth2令牌是授权系统的核心，Spring Security提供了多种令牌存储策略，包括内存存储、数据库存储、Redis存储以及JWT（JSON Web Token）。JWT特别流行，因为它是自包含的，减少了后端存储需求。令牌策略配置包括令牌格式、有效期、刷新机制等。开发者可以通过TokenStore和TokenEnhancer接口自定义令牌的存储和增强逻辑，如添加额外的业务信息到令牌中。选择合适的令牌策略对系统性能和安全性有重要影响。

// 不同令牌存储策略的配置
@Configuration
public class TokenStoreConfig {

@Autowired
private DataSource dataSource;

@Autowired
private RedisConnectionFactory redisConnectionFactory;

// 内存令牌存储
@Bean
@Profile("dev")
public TokenStore inMemoryTokenStore() {
return new InMemoryTokenStore();
}

// JDBC令牌存储
@Bean
@Profile("prod")
public TokenStore jdbcTokenStore() {
return new JdbcTokenStore(dataSource);
}

// Redis令牌存储
@Bean
@Profile("cluster")
public TokenStore redisTokenStore() {
return new RedisTokenStore(redisConnectionFactory);
}

// JWT令牌存储
@Bean
@Profile("jwt")
public TokenStore jwtTokenStore() {
return new JwtTokenStore(jwtAccessTokenConverter());
}

@Bean
@Profile("jwt")
public JwtAccessTokenConverter jwtAccessTokenConverter() {
JwtAccessTokenConverter converter = new JwtAccessTokenConverter();

// 对称密钥签名
converter.setSigningKey("secret-signing-key");

// 非对称密钥签名（更安全）
// KeyPair keyPair = new KeyStoreKeyFactory(
// new ClassPathResource("keystore.jks"), "password".toCharArray()
// ).getKeyPair("alias");
// converter.setKeyPair(keyPair);

return converter;
}

// 自定义令牌服务，控制令牌生成策略
@Bean
public DefaultTokenServices tokenServices(TokenStore tokenStore) {
DefaultTokenServices tokenServices = new DefaultTokenServices();
tokenServices.setTokenStore(tokenStore);
tokenServices.setSupportRefreshToken(true);
tokenServices.setAccessTokenValiditySeconds(3600); // 1小时
tokenServices.setRefreshTokenValiditySeconds(86400); // 1天
return tokenServices;
}
}

四、资源服务器配置

资源服务器保护应用的API资源，确保只有持有有效令牌的请求才能访问。在Spring Security中，通过@EnableResourceServer注解和继承ResourceServerConfigurerAdapter来配置资源服务器。关键配置包括资源ID（标识受保护的资源集合）、令牌服务（验证令牌的有效性）、资源访问规则（定义URL级别的保护策略）以及异常处理（如处理令牌无效或过期的情况）。资源服务器通常需要与授权服务器协调，共享令牌验证信息。

@Configuration
@EnableResourceServer
public class ResourceServerConfig extends ResourceServerConfigurerAdapter {

private static final String RESOURCE_ID = "api-resource";

@Override
public void configure(ResourceServerSecurityConfigurer resources) {
resources
.resourceId(RESOURCE_ID) // 设置资源ID
.tokenStore(tokenStore()) // 设置令牌存储
.tokenExtractor(new BearerTokenExtractor()) // 令牌提取器
.authenticationEntryPoint(new OAuth2AuthenticationEntryPoint()) // 认证入口点
.accessDeniedHandler(new OAuth2AccessDeniedHandler()); // 访问拒绝处理器
}

@Override
public void configure(HttpSecurity http) throws Exception {
// 配置受保护资源的访问规则
http
.requestMatchers()
.antMatchers("/api/**") // 仅应用于/api路径下的资源
.and()
.authorizeRequests()
.antMatchers(HttpMethod.GET, "/api/public/**").permitAll() // 公共资源
.antMatchers("/api/admin/**").hasRole("ADMIN") // 管理员资源
.antMatchers("/api/users/**").access("#oauth2.hasScope('read')") // 基于作用域控制
.antMatchers(HttpMethod.POST, "/api/**").access("#oauth2.hasScope('write')") // 写操作需要write作用域
.anyRequest().authenticated() // 其他请求需要认证
.and()
.exceptionHandling()
.accessDeniedHandler(new OAuth2AccessDeniedHandler()); // 自定义访问拒绝处理
}

@Bean
public TokenStore tokenStore() {
// 与授权服务器使用相同的令牌存储方式
return new JwtTokenStore(accessTokenConverter());
}

@Bean
public JwtAccessTokenConverter accessTokenConverter() {
JwtAccessTokenConverter converter = new JwtAccessTokenConverter();
converter.setSigningKey("secret-key"); // 使用与授权服务器相同的签名密钥
return converter;
}

// 自定义方法级安全控制
@Bean
public MethodSecurityExpressionHandler methodSecurityExpressionHandler() {
OAuth2MethodSecurityExpressionHandler expressionHandler = new OAuth2MethodSecurityExpressionHandler();
return expressionHandler;
}
}

// 为不同微服务配置不同的资源ID和访问规则
@Configuration
@EnableResourceServer
public class UserServiceResourceConfig extends ResourceServerConfigurerAdapter {

private static final String RESOURCE_ID = "user-service";

@Override
public void configure(ResourceServerSecurityConfigurer resources) {
resources.resourceId(RESOURCE_ID);
}

@Override
public void configure(HttpSecurity http) throws Exception {
http
.requestMatchers()
.antMatchers("/users/**")
.and()
.authorizeRequests()
.antMatchers("/users/profile/**").access("#oauth2.hasScope('user_profile')")
.antMatchers("/users/admin/**").hasRole("USER_ADMIN")
.anyRequest().authenticated();
}
}

五、远程令牌验证与内省

在分布式系统中，资源服务器需要验证请求中携带的令牌有效性。Spring Security提供了两种主要方式：远程令牌验证（资源服务器通过HTTP请求调用授权服务器的检查令牌端点）和本地令牌验证（使用共享密钥在本地验证JWT令牌）。对于非JWT令牌，通常采用OAuth2内省协议（RFC 7662）进行验证。内省允许资源服务器查询令牌的当前状态，包括是否有效、关联的范围和期限等。合理配置令牌验证机制对系统性能和安全性具有重要影响。

@Configuration
@EnableResourceServer
public class RemoteTokenValidationConfig extends ResourceServerConfigurerAdapter {

@Autowired
private Environment env;

@Override
public void configure(ResourceServerSecurityConfigurer resources) throws Exception {
resources
.tokenServices(remoteTokenServices())
.stateless(true);
}

// 远程令牌服务配置（适用于非JWT令牌）
@Bean
public RemoteTokenServices remoteTokenServices() {
RemoteTokenServices tokenServices = new RemoteTokenServices();

// 设置检查令牌端点URL
tokenServices.setCheckTokenEndpointUrl(
env.getProperty("auth-server.url") + "/oauth/check_token");

// 设置客户端凭据
tokenServices.setClientId(env.getProperty("auth-server.client-id"));
tokenServices.setClientSecret(env.getProperty("auth-server.client-secret"));

// 设置自定义访问器适配器（可选）
tokenServices.setAccessTokenConverter(accessTokenConverter());

return tokenServices;
}

@Bean
public AccessTokenConverter accessTokenConverter() {
DefaultAccessTokenConverter converter = new DefaultAccessTokenConverter();

// 自定义用户信息提取
DefaultUserAuthenticationConverter userConverter = new DefaultUserAuthenticationConverter();
userConverter.setUserDetailsService(userDetailsService());

converter.setUserTokenConverter(userConverter);
return converter;
}

@Bean
public UserDetailsService userDetailsService() {
// 实现用户详情服务，用于将令牌中的用户信息转换为UserDetails对象
return new CustomUserDetailsService();
}
}

// OAuth2内省客户端配置
@Configuration
public class OAuth2IntrospectionConfig {

@Value("${oauth2.introspection.url}")
private String introspectionUrl;

@Value("${oauth2.client.id}")
private String clientId;

@Value("${oauth2.client.secret}")
private String clientSecret;

@Bean
public OAuth2IntrospectionAuthenticationManager introspectionAuthenticationManager() {
OAuth2IntrospectionAuthenticationProvider provider =
new OAuth2IntrospectionAuthenticationProvider(introspectionClient());

return new OAuth2IntrospectionAuthenticationManager(provider);
}

@Bean
public OAuth2IntrospectionClient introspectionClient() {
return new OAuth2IntrospectionClient() {
@Override
public OAuth2TokenIntrospection introspect(String token) {
// 实现内省请求逻辑
RestTemplate restTemplate = new RestTemplate();

// 设置Basic认证头
HttpHeaders headers = new HttpHeaders();
headers.setBasicAuth(clientId, clientSecret);

// 构建请求体
MultiValueMap<String, String> body = new LinkedMultiValueMap<>();
body.add("token", token);

// 发送内省请求
HttpEntity<MultiValueMap<String, String>> request =
new HttpEntity<>(body, headers);

try {
ResponseEntity<Map<String, Object>> response = restTemplate.exchange(
introspectionUrl,
HttpMethod.POST,
request,
new ParameterizedTypeReference<Map<String, Object>>() {}
);

// 解析响应
Map<String, Object> introspectionData = response.getBody();
return new DefaultOAuth2TokenIntrospection(introspectionData);
} catch (Exception e) {
throw new OAuth2IntrospectionException("令牌内省失败", e);
}
}
};
}
}

总结

Spring Security OAuth2提供了强大而灵活的机制，用于实现标准化的授权服务器和资源服务器。通过合理配置授权服务器，开发者可以自定义客户端注册、授权类型、令牌策略等，满足不同应用场景的需求。令牌存储策略的选择应基于系统性能、安全性和部署环境等因素，JWT令牌因其自包含特性在微服务架构中尤为适用。资源服务器配置则专注于保护API资源，通过URL级别和方法级别的安全控制，确保只有持有有效令牌且具备适当权限的请求才能访问受保护资源。在分布式系统中，资源服务器可通过远程令牌验证或内省机制与授权服务器协同工作，也可利用JWT的自验证特性在本地完成令牌验证。虽然Spring Security OAuth项目已进入维护模式，但其核心概念和配置模式仍适用于现有系统，而新项目则可考虑使用Spring Authorization Server作为替代。通过掌握这些配置技术，开发者能够构建安全、标准化且高效的OAuth2实现，为分布式应用提供可靠的认证与授权保障。