spring cloud 微服务下统一认证授权

一. 前置知识

1. 认证授权解决方案

  • 理想的解决方案 

    1. 我们理想的解决方案应该是这样的，认证服务负责认证，网关负责校验认证和鉴权，其他API服务负责处理自己的业务逻辑。安全相关的逻辑只存在于认证服务和网关服务中，其他服务只是单纯地提供服务而没有任何安全相关逻辑。

  • 微服务下的三种访问场景

    1. 外部访问通过gateway，需要鉴权，用户登录后可访问的资源
    2. 外部访问通过gateway，不需要鉴权，比如验证码、静态文件等资源，需要将url加入到spring security的白名单中
    3. 内部服务通过Feign访问，不需要鉴权，可单独进行配置，只允许内部互相调用，不允许通过gateway调用
  • 应用架构
    • micro-auth 统一认证服务器，负责对用户登录请求的认证工作
      spring security + spring Oauth2
    • micro-gateway 资源管理服务器，负责对请求的统一鉴权、转发、管理工作
      spring security + spring Oauth2
    • micro-upms 等 普通服务，不整合 安全模块
  • 微服务间鉴权
    微服务间鉴权，feign调用时，增加请求头标识，标识为feign请求，服务拦截器统一拦截feign请求
    请求经过网关时，请求feign标识请求头，防止请求伪造
  • 网关-微服务，用户信息传递
    网关解析token，获取用户信息，将用户信息放置请求头
    微服务拦截器拦截请求头，获取用户信息，放置ThreadLocal线程池内

二. OAuth2 和 JWT相关知识

1. OAuth2

1.1 什么是Oauth2？

  1. OAUth2就是一套广泛流行的认证授权协议，大白话说呢OAuth2这套协议中有两个核心的角色，认证服务器和资源服务器。

2. JWT

2.1 什么是 jwt？

  1. JSON Web Token (JWT)是一个开放标准(RFC 7519)，它定义了一种紧凑的、自包含的方式，用于作为JSON对象在各方之间安全地传输信息。该信息可以被验证和信任，因为它是数字签名的。

2.2 jwt 组成 头部、负载、签名

  • header+payload+signature
    • 头部：主要是描述签名算法
    • 负载：主要描述是加密对象的信息，如用户的id等，也可以加些规范里面的东西，如iss签发者，exp 过期时间，sub 面向的用户
    • 签名：主要是把前面两部分进行加密，防止别人拿到token进行base解密后篡改token

三. 认证服务器

1. 依赖

  1.         <dependency>
  2.             <groupId>org.springframework.security.oauth.boot</groupId>
  3.             <artifactId>spring-security-oauth2-autoconfigure</artifactId>
  4.         </dependency>
  6.         <dependency>
  7.             <groupId>org.springframework.security</groupId>
  8.             <artifactId>spring-security-oauth2-jose</artifactId>
  9.         </dependency>

2. 认证服务器配置 (初版，后续更改) (详细使用spring security系列文章)

2.1 Spring security配置

  1. @Configuration
  2. @EnableWebSecurity
  3. public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
  4.     /**
  5.      * 认证中心默认忽略验证地址
  6.      */
  7.     private static final String[] SECURITY_ENDPOINTS = {
  8.             "/auth/**",
  9.             "/oauth/token",
  10.             "/login/*",
  11.             "/actuator/**",
  12.             "/v2/api-docs",
  13.             "/doc.html",
  14.             "/webjars/**",
  15.             "**/favicon.ico",
  16.             "/swagger-resources/**"
  17.     };
  19.     @Override
  20.     protected void configure(HttpSecurity http) throws Exception {
  21.         ExpressionUrlAuthorizationConfigurer<HttpSecurity>.ExpressionInterceptUrlRegistry config
  22.                 = http.requestMatchers().anyRequest()
  23.                 .and()
  24.                 .formLogin()
  25.                 .and()
  26. //                .apply(smsCodeAuthenticationSecurityConfig)
  27. //                .and()
  28. //                .apply(socialAuthenticationSecurityConfig)
  29. //                .and()
  30.                 .authorizeRequests();
  31.         List<String> list = new ArrayList<>();
  32.         Collections.addAll(list, SECURITY_ENDPOINTS);
  33.         list.forEach(url -> {
  34.             config.antMatchers(url).permitAll();
  35.         });
  36.         config
  37.                 //任何请求
  38.                 .anyRequest()
  39.                 //都需要身份认证
  40.                 .authenticated()
  41.                 //csrf跨站请求
  42.                 .and()
  43.                 .csrf().disable();
  44.     }
  46.     @Bean
  47.     @Override
  48.     public AuthenticationManager authenticationManagerBean() throws Exception {
  49.         return super.authenticationManagerBean();
  50.     }
  52.     @Bean
  53.     public PasswordEncoder passwordEncoder() {
  54.         return new BCryptPasswordEncoder();
  55.     }
  57. }

2.2 Spring Oauth2配置 (后续修改，测试使用版本)

  1. @AllArgsConstructor
  2. @Configuration
  3. @EnableAuthorizationServer
  4. public class Oauth2ServerConfig extends AuthorizationServerConfigurerAdapter {
  6.     @Autowired
  7.     private PasswordEncoder passwordEncoder;
  8.     @Autowired
  9.     private UserServiceImpl userDetailsService;
  10.     @Autowired
  11.     private AuthenticationManager authenticationManager;
  12.     @Autowired
  13.     private JwtTokenEnhancer jwtTokenEnhancer;
  14.     @Autowired
  15.     private WebRespExceptionTranslator webRespExceptionTranslator;
  17.     /**
  18.      * redis 链接工厂
  19.      * */
  20.     @Autowired
  21.     private RedisConnectionFactory redisConnectionFactory;
  23.     /**
  24.      * Oauth2 与redis链接
  25.      * */
  26.     @Bean
  27.     public TokenStore tokenStore(){
  28.         return new RedisTokenStore(redisConnectionFactory);
  29.     }
  31.     /**
  32.      * 配置第三方应用
  33.      * 四种授权码模式
  34.      * 1. code码授权   authorization_code
  35.      * 2. 静默授权      implicit
  36.      * 3. 密码授权 特别信任的第三方应用 password
  37.      * 4. 客户端授权     client_credentials
  38.      * */
  39.     @Override
  40.     public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
  41.         clients.inMemory()
  42.                 .withClient("admin-app")   // 第三方应用的客户端id
  43.                 .secret(passwordEncoder.encode("123456"))   //配置第三方应用的密码
  44.                 .scopes("all") // 配置第三方应用的业务作用域
  45.                 .authorizedGrantTypes("password", "refresh_token")  //四种授权模式
  46.                 .accessTokenValiditySeconds(3600*24)
  47.                 .refreshTokenValiditySeconds(3600*24*7)
  48.                 // 授权后跳转的地址
  49.                 //.redirectUris("http://www.baidu.com")
  50.                 .and()
  51.                 .withClient("portal-app")
  52.                 .secret("123456")
  53.                 .scopes("all")
  54.                 .authorizedGrantTypes("password", "refresh_token")
  55.                 .accessTokenValiditySeconds(3600*24)
  56.                 .refreshTokenValiditySeconds(3600*24*7);
  57.     }
  59.     @Override
  60.     public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
  61.         TokenEnhancerChain enhancerChain = new TokenEnhancerChain();
  62.         List<TokenEnhancer> delegates = new ArrayList<>();
  63.         delegates.add(jwtTokenEnhancer);
  64.         delegates.add(accessTokenConverter());
  65.         enhancerChain.setTokenEnhancers(delegates); //配置JWT的内容增强器
  66.         endpoints.tokenStore(tokenStore())
  67.                 .authenticationManager(authenticationManager)
  68.                 .userDetailsService(userDetailsService) //配置加载用户信息的服务
  69.                 .accessTokenConverter(accessTokenConverter())
  70.                 .exceptionTranslator(webRespExceptionTranslator)
  71.                 .tokenEnhancer(enhancerChain);
  72.     }
  74.     @Override
  75.     public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
  76.         security.allowFormAuthenticationForClients();
  77.     }
  80.     @Bean
  81.     public JwtAccessTokenConverter accessTokenConverter() {
  82.         JwtAccessTokenConverter jwtAccessTokenConverter = new JwtAccessTokenConverter();
  83.         jwtAccessTokenConverter.setKeyPair(keyPair());
  84.         return jwtAccessTokenConverter;
  85.     }
  87.     @Bean
  88.     public KeyPair keyPair() {
  89.         //从classpath下的证书中获取秘钥对
  90.         KeyStoreKeyFactory keyStoreKeyFactory = new KeyStoreKeyFactory(new ClassPathResource("ffzs-jwt.jks"), "ffzs00".toCharArray());
  91.         KeyPair keyPair = keyStoreKeyFactory.getKeyPair("ffzs-jwt", "ffzs00".toCharArray());
  92.         return keyPair;
  93.     }
  95. }

2.3 RSA

  1. 生成密钥库
    使用JDK工具的keytool生成JKS密钥库(Java key Store), 将生成后的文件放到resource目录 
    1. keytool -genkey -alias ffzs-jwt -keyalg RSA -keypass ffzs00 -keystore ffzs-jwt.jks -storepass ffzs00
    ``` -genkey 生成密钥

-alias 别名

-keyalg 密钥算法

-keypass 密钥口令

-keystore 生成密钥库的存储路径和名称

-storepass 密钥库口令

  2.    2. 生成公钥文件
  5. <a name="607fd992"></a>
  6. ## 四. 资源服务器
  8. <a name="f80d16f6-1"></a>
  9. ### 1. 依赖
  11. ```xml
  12.         <!-- OAuth2资源服务器-->
  13.         <dependency>
  14.             <groupId>org.springframework.security</groupId>
  15.             <artifactId>spring-security-config</artifactId>
  16.         </dependency>
  17.         <dependency>
  18.             <groupId>org.springframework.security</groupId>
  19.             <artifactId>spring-security-oauth2-resource-server</artifactId>
  20.         </dependency>
  21.         <dependency>
  22.             <groupId>org.springframework.security</groupId>
  23.             <artifactId>spring-security-oauth2-jose</artifactId>
  24.         </dependency>
  26.         <dependency>
  27.             <groupId>com.github.xiaoymin</groupId>
  28.             <artifactId>knife4j-spring-boot-starter</artifactId>
  29.         </dependency>

2. 资源服务器配置

2.1 资源服务器配置文件（后续jwt公钥验证修改为本地验证）

  1. /**
  2.  * 资源服务器配置
  3.  * Created by macro on 2020/6/19.
  4.  */
  5. @AllArgsConstructor
  6. @Configuration
  7. @EnableWebFluxSecurity
  8. public class ResourceServerConfig {
  9.     private final AuthorizationManager authorizationManager;
  10.     private final IgnoreUrlsConfig ignoreUrlsConfig;
  11.     private final RestfulAccessDeniedHandler restfulAccessDeniedHandler;
  12.     private final RestAuthenticationEntryPoint restAuthenticationEntryPoint;
  13.     private final IgnoreUrlsRemoveJwtFilter ignoreUrlsRemoveJwtFilter;
  15.     @Bean
  16.     public SecurityWebFilterChain springSecurityFilterChain(ServerHttpSecurity http) {
  17.         http.oauth2ResourceServer().jwt()
  18.                 .jwtAuthenticationConverter(jwtAuthenticationConverter());
  19.         //自定义处理JWT请求头过期或签名错误的结果
  20.         http.oauth2ResourceServer().authenticationEntryPoint(restAuthenticationEntryPoint);
  21.         http.authorizeExchange()
  22.                 .pathMatchers(ArrayUtil.toArray(ignoreUrlsConfig.getUrls(),String.class)).permitAll()//白名单配置
  23.                 .anyExchange().access(authorizationManager)//鉴权管理器配置
  24.                 .and().exceptionHandling()
  25.                 .accessDeniedHandler(restfulAccessDeniedHandler)//处理未授权
  26.                 .authenticationEntryPoint(restAuthenticationEntryPoint)//处理未认证
  27.                 .and().csrf().disable();
  28.         return http.build();
  29.     }
  31.     @Bean
  32.     public Converter<Jwt, ? extends Mono<? extends AbstractAuthenticationToken>> jwtAuthenticationConverter() {
  33.         JwtGrantedAuthoritiesConverter jwtGrantedAuthoritiesConverter = new JwtGrantedAuthoritiesConverter();
  34.         jwtGrantedAuthoritiesConverter.setAuthorityPrefix(AuthConstant.AUTHORITY_PREFIX);
  35.         jwtGrantedAuthoritiesConverter.setAuthoritiesClaimName(AuthConstant.AUTHORITY_CLAIM_NAME);
  36.         JwtAuthenticationConverter jwtAuthenticationConverter = new JwtAuthenticationConverter();
  37.         jwtAuthenticationConverter.setJwtGrantedAuthoritiesConverter(jwtGrantedAuthoritiesConverter);
  38.         return new ReactiveJwtAuthenticationConverterAdapter(jwtAuthenticationConverter);
  39.     }
  41. }

2.2 鉴权管理器 (逻辑不完善，后续修改)

  1. /**
  2.  * 鉴权管理器，用于判断是否有资源的访问权限
  3.  * Created by macro on 2020/6/19.
  4.  */
  5. @Component
  6. public class AuthorizationManager implements ReactiveAuthorizationManager<AuthorizationContext> {
  7.     @Autowired
  8.     private RedisTemplate<String, Object> redisTemplate;
  9.     @Autowired
  10.     private IgnoreUrlsConfig ignoreUrlsConfig;
  12.     @Override
  13.     public Mono<AuthorizationDecision> check(Mono<Authentication> mono, AuthorizationContext authorizationContext) {
  14.         ServerHttpRequest request = authorizationContext.getExchange().getRequest();
  15.         URI uri = request.getURI();
  16.         PathMatcher pathMatcher = new AntPathMatcher();
  17.         //白名单路径直接放行
  18.         List<String> ignoreUrls = ignoreUrlsConfig.getUrls();
  19.         for (String ignoreUrl : ignoreUrls) {
  20.             if (pathMatcher.match(ignoreUrl, uri.getPath())) {
  21.                 return Mono.just(new AuthorizationDecision(true));
  22.             }
  23.         }
  24.         //对应跨域的预检请求直接放行
  25.         if(request.getMethod()==HttpMethod.OPTIONS){
  26.             return Mono.just(new AuthorizationDecision(true));
  27.         }
  29.         //管理端路径需校验权限
  30.         Map<Object, Object> resourceRolesMap = redisTemplate.opsForHash().entries(AuthConstant.RESOURCE_ROLES_MAP_KEY);
  31.         Iterator<Object> iterator = resourceRolesMap.keySet().iterator();
  32.         List<String> authorities = new ArrayList<>();
  33.         while (iterator.hasNext()) {
  34.             String pattern = (String) iterator.next();
  35.             if (pathMatcher.match(pattern, uri.getPath())) {
  36.                 authorities.addAll(Convert.toList(String.class, resourceRolesMap.get(pattern)));
  37.             }
  38.         }
  39.         authorities = authorities.stream().map(i -> i = AuthConstant.AUTHORITY_PREFIX + i).collect(Collectors.toList());
  40.         //认证通过且角色匹配的用户可访问当前路径
  41.         return mono
  42.                 .filter(Authentication::isAuthenticated)
  43.                 .flatMapIterable(Authentication::getAuthorities)
  44.                 .map(GrantedAuthority::getAuthority)
  45.                 .any(authorities::contains)
  46.                 .map(AuthorizationDecision::new)
  47.                 .defaultIfEmpty(new AuthorizationDecision(false));
  48.     }
  50. }

2.3 过滤器（逻辑不完善，后续修改)