devbox
你好赵伟
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

SpringCloud Gateway + Jwt + Oauth2 实现网关的鉴权操作

作者：你好赵伟 | 2024-02-08 11:33:07

赞

踩

@enablewebfluxsecurity 引入哪个包

点击上方“芋道源码”，选择“设为星标”

管她前浪，还是后浪？

能浪的浪，才是好浪！

每天 10:33 更新文章，每天掉亿点点头发...

源码精品专栏

 

来源：juejin.cn/post/

7000353332824899614

一、背景

随着我们的微服务越来越多，如果每个微服务都要自己去实现一套鉴权操作，那么这么操作比较冗余，因此我们可以把鉴权操作统一放到网关去做，如果微服务自己有额外的鉴权处理，可以在自己的微服务中处理。

基于 Spring Boot + MyBatis Plus + Vue & Element 实现的后台管理系统 + 用户小程序，支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

  • 项目地址：https://gitee.com/zhijiantianya/ruoyi-vue-pro

  • 视频教程：https://doc.iocoder.cn/video/

二、需求

1、在网关层完成url层面的鉴权操作。

  • 所有的OPTION请求都放行。

  • 所有不存在请求，直接都拒绝访问。

  • user-provider服务的findAllUsers需要 user.userInfo权限才可以访问。

2、将解析后的jwt token当做请求头传递到下游服务中。3、整合Spring Security Oauth2 Resource Server

基于 Spring Cloud Alibaba + Gateway + Nacos + RocketMQ + Vue & Element 实现的后台管理系统 + 用户小程序，支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

  • 项目地址：https://gitee.com/zhijiantianya/yudao-cloud

  • 视频教程：https://doc.iocoder.cn/video/

三、前置条件

1、搭建一个可用的认证服务器

https://juejin.cn/post/6985411823144615972

2、知道Spring Security Oauth2 Resource Server资源服务器如何使用

https://juejin.cn/post/6985893815500406791

四、项目结构

e70f5526a2f6313a3e0774e6dab6ab79.jpeg
项目结构

五、网关层代码的编写

1、引入jar包

  1. <dependency>
  2.     <groupId>com.alibaba.cloud</groupId>
  3.     <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
  4. </dependency>
  5. <dependency>
  6.     <groupId>org.springframework.cloud</groupId>
  7.     <artifactId>spring-cloud-starter-gateway</artifactId>
  8. </dependency>
  9. <dependency>
  10.     <groupId>org.springframework.boot</groupId>
  11.     <artifactId>spring-boot-starter-oauth2-resource-server</artifactId>
  12. </dependency>
  13. <dependency>
  14.     <groupId>org.springframework.boot</groupId>
  15.     <artifactId>spring-boot-starter-security</artifactId>
  16. </dependency>
  17. <dependency>
  18.     <groupId>org.springframework.cloud</groupId>
  19.     <artifactId>spring-cloud-starter-loadbalancer</artifactId>
  20. </dependency>

2、自定义授权管理器

自定义授权管理器，判断用户是否有权限访问

此处我们简单判断

  • 放行所有的 OPTION 请求。

  • 判断某个请求(url)用户是否有权限访问。

  • 所有不存在的请求(url)直接无权限访问。

  1. package com.huan.study.gateway.config;
  2.  
  3. import com.google.common.collect.Maps;
  4. import lombok.extern.slf4j.Slf4j;
  5. import org.springframework.http.HttpMethod;
  6. import org.springframework.http.server.reactive.ServerHttpRequest;
  7. import org.springframework.security.authentication.AbstractAuthenticationToken;
  8. import org.springframework.security.authorization.AuthorizationDecision;
  9. import org.springframework.security.authorization.ReactiveAuthorizationManager;
  10. import org.springframework.security.core.Authentication;
  11. import org.springframework.security.core.GrantedAuthority;
  12. import org.springframework.security.oauth2.server.resource.authentication.JwtAuthenticationToken;
  13. import org.springframework.security.web.server.authorization.AuthorizationContext;
  14. import org.springframework.stereotype.Component;
  15. import org.springframework.util.AntPathMatcher;
  16. import org.springframework.util.PathMatcher;
  17. import org.springframework.util.StringUtils;
  18. import org.springframework.web.server.ServerWebExchange;
  19. import reactor.core.publisher.Mono;
  20.  
  21. import javax.annotation.PostConstruct;
  22. import java.util.Map;
  23. import java.util.Objects;
  24.  
  25. /**
  26.  * 自定义授权管理器，判断用户是否有权限访问
  27.  */
  28. @Component
  29. @Slf4j
  30. public class CustomReactiveAuthorizationManager implements ReactiveAuthorizationManager<AuthorizationContext> {
  31.  
  32.     /**
  33.      * 此处保存的是资源对应的权限，可以从数据库中获取
  34.      */
  35.     private static final Map<String, String> AUTH_MAP = Maps.newConcurrentMap();
  36.  
  37.     @PostConstruct
  38.     public void initAuthMap() {
  39.         AUTH_MAP.put("/user/findAllUsers", "user.userInfo");
  40.         AUTH_MAP.put("/user/addUser", "ROLE_ADMIN");
  41.     }
  42.  
  43.  
  44.     @Override
  45.     public Mono<AuthorizationDecision> check(Mono<Authentication> authentication, AuthorizationContext authorizationContext) {
  46.         ServerWebExchange exchange = authorizationContext.getExchange();
  47.         ServerHttpRequest request = exchange.getRequest();
  48.         String path = request.getURI().getPath();
  49.  
  50.         // 带通配符的可以使用这个进行匹配
  51.         PathMatcher pathMatcher = new AntPathMatcher();
  52.         String authorities = AUTH_MAP.get(path);
  53.         log.info("访问路径:[{}],所需要的权限是:[{}]", path, authorities);
  54.  
  55.         // option 请求，全部放行
  56.         if (request.getMethod() == HttpMethod.OPTIONS) {
  57.             return Mono.just(new AuthorizationDecision(true));
  58.         }
  59.  
  60.         // 不在权限范围内的url，全部拒绝
  61.         if (!StringUtils.hasText(authorities)) {
  62.             return Mono.just(new AuthorizationDecision(false));
  63.         }
  64.  
  65.         return authentication
  66.                 .filter(Authentication::isAuthenticated)
  67.                 .filter(a -> a instanceof JwtAuthenticationToken)
  68.                 .cast(JwtAuthenticationToken.class)
  69.                 .doOnNext(token -> {
  70.                     System.out.println(token.getToken().getHeaders());
  71.                     System.out.println(token.getTokenAttributes());
  72.                 })
  73.                 .flatMapIterable(AbstractAuthenticationToken::getAuthorities)
  74.                 .map(GrantedAuthority::getAuthority)
  75.                 .any(authority -> Objects.equals(authority, authorities))
  76.                 .map(AuthorizationDecision::new)
  77.                 .defaultIfEmpty(new AuthorizationDecision(false));
  78.     }
  79. }

3、token认证失败、或超时的处理

  1. package com.huan.study.gateway.config;
  2.  
  3. import org.springframework.core.io.buffer.DataBuffer;
  4. import org.springframework.core.io.buffer.DataBufferUtils;
  5. import org.springframework.http.HttpStatus;
  6. import org.springframework.security.core.AuthenticationException;
  7. import org.springframework.security.web.server.ServerAuthenticationEntryPoint;
  8. import org.springframework.web.server.ServerWebExchange;
  9. import reactor.core.publisher.Mono;
  10.  
  11. import java.nio.charset.StandardCharsets;
  12.  
  13. /**
  14.  * 认证失败异常处理
  15.  */
  16. public class CustomServerAuthenticationEntryPoint implements ServerAuthenticationEntryPoint {
  17.     @Override
  18.     public Mono<Void> commence(ServerWebExchange exchange, AuthenticationException ex) {
  19.  
  20.         return Mono.defer(() -> Mono.just(exchange.getResponse()))
  21.                 .flatMap(response -> {
  22.                     response.setStatusCode(HttpStatus.UNAUTHORIZED);
  23.                     String body = "{\"code\":401,\"msg\":\"token不合法或过期\"}";
  24.                     DataBuffer buffer = response.bufferFactory().wrap(body.getBytes(StandardCharsets.UTF_8));
  25.                     return response.writeWith(Mono.just(buffer))
  26.                             .doOnError(error -> DataBufferUtils.release(buffer));
  27.                 });
  28.     }
  29. }

4、用户没有权限的处理

  1. package com.huan.study.gateway.config;
  2.  
  3. import lombok.extern.slf4j.Slf4j;
  4. import org.springframework.context.annotation.Bean;
  5. import org.springframework.core.io.buffer.DataBuffer;
  6. import org.springframework.core.io.buffer.DataBufferUtils;
  7. import org.springframework.http.HttpStatus;
  8. import org.springframework.http.server.reactive.ServerHttpRequest;
  9. import org.springframework.http.server.reactive.ServerHttpResponse;
  10. import org.springframework.security.access.AccessDeniedException;
  11. import org.springframework.security.web.server.authorization.ServerAccessDeniedHandler;
  12. import org.springframework.web.server.ServerWebExchange;
  13. import reactor.core.publisher.Mono;
  14.  
  15. import java.nio.charset.StandardCharsets;
  16.  
  17. /**
  18.  * 无权限访问异常
  19.  */
  20. @Slf4j
  21. public class CustomServerAccessDeniedHandler implements ServerAccessDeniedHandler {
  22.  
  23.     @Override
  24.     public Mono<Void> handle(ServerWebExchange exchange, AccessDeniedException denied) {
  25.  
  26.         ServerHttpRequest request = exchange.getRequest();
  27.  
  28.         return exchange.getPrincipal()
  29.                 .doOnNext(principal -> log.info("用户:[{}]没有访问:[{}]的权限.", principal.getName(), request.getURI()))
  30.                 .flatMap(principal -> {
  31.                     ServerHttpResponse response = exchange.getResponse();
  32.                     response.setStatusCode(HttpStatus.FORBIDDEN);
  33.                     String body = "{\"code\":403,\"msg\":\"您无权限访问\"}";
  34.                     DataBuffer buffer = response.bufferFactory().wrap(body.getBytes(StandardCharsets.UTF_8));
  35.                     return response.writeWith(Mono.just(buffer))
  36.                             .doOnError(error -> DataBufferUtils.release(buffer));
  37.                 });
  38.     }
  39. }

5、将token信息传递到下游服务器中

  1. package com.huan.study.gateway.config;
  2.  
  3. import com.fasterxml.jackson.core.JsonProcessingException;
  4. import com.fasterxml.jackson.databind.ObjectMapper;
  5. import com.fasterxml.jackson.datatype.jdk8.Jdk8Module;
  6. import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
  7. import org.springframework.http.server.reactive.ServerHttpRequest;
  8. import org.springframework.security.core.context.ReactiveSecurityContextHolder;
  9. import org.springframework.security.core.context.SecurityContext;
  10. import org.springframework.security.oauth2.server.resource.authentication.JwtAuthenticationToken;
  11. import org.springframework.web.server.ServerWebExchange;
  12. import org.springframework.web.server.WebFilter;
  13. import org.springframework.web.server.WebFilterChain;
  14. import reactor.core.publisher.Mono;
  15.  
  16. /**
  17.  * 将token信息传递到下游服务中
  18.  *
  19.  * @author huan.fu 2021/8/25 - 下午2:49
  20.  */
  21. public class TokenTransferFilter implements WebFilter {
  22.  
  23.     private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
  24.  
  25.     static {
  26.         OBJECT_MAPPER.registerModule(new Jdk8Module());
  27.         OBJECT_MAPPER.registerModule(new JavaTimeModule());
  28.     }
  29.  
  30.     @Override
  31.     public Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain) {
  32.         return ReactiveSecurityContextHolder.getContext()
  33.                 .map(SecurityContext::getAuthentication)
  34.                 .cast(JwtAuthenticationToken.class)
  35.                 .flatMap(authentication -> {
  36.                     ServerHttpRequest request = exchange.getRequest();
  37.                     request = request.mutate()
  38.                             .header("tokenInfo", toJson(authentication.getPrincipal()))
  39.                             .build();
  40.  
  41.                     ServerWebExchange newExchange = exchange.mutate().request(request).build();
  42.  
  43.                     return chain.filter(newExchange);
  44.                 });
  45.     }
  46.  
  47.     public String toJson(Object obj) {
  48.         try {
  49.             return OBJECT_MAPPER.writeValueAsString(obj);
  50.         } catch (JsonProcessingException e) {
  51.             return null;
  52.         }
  53.     }
  54. }

6、网关层面的配置

  1. package com.huan.study.gateway.config;
  2.  
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.context.annotation.Bean;
  5. import org.springframework.context.annotation.Configuration;
  6. import org.springframework.core.convert.converter.Converter;
  7. import org.springframework.core.io.FileSystemResource;
  8. import org.springframework.core.io.Resource;
  9. import org.springframework.security.authentication.AbstractAuthenticationToken;
  10. import org.springframework.security.config.annotation.web.reactive.EnableWebFluxSecurity;
  11. import org.springframework.security.config.web.server.SecurityWebFiltersOrder;
  12. import org.springframework.security.config.web.server.ServerHttpSecurity;
  13. import org.springframework.security.oauth2.jose.jws.SignatureAlgorithm;
  14. import org.springframework.security.oauth2.jwt.Jwt;
  15. import org.springframework.security.oauth2.jwt.NimbusReactiveJwtDecoder;
  16. import org.springframework.security.oauth2.jwt.ReactiveJwtDecoder;
  17. import org.springframework.security.oauth2.server.resource.authentication.JwtAuthenticationConverter;
  18. import org.springframework.security.oauth2.server.resource.authentication.JwtGrantedAuthoritiesConverter;
  19. import org.springframework.security.oauth2.server.resource.authentication.ReactiveJwtAuthenticationConverterAdapter;
  20. import org.springframework.security.oauth2.server.resource.web.server.ServerBearerTokenAuthenticationConverter;
  21. import org.springframework.security.web.server.SecurityWebFilterChain;
  22. import reactor.core.publisher.Mono;
  23.  
  24. import java.io.IOException;
  25. import java.nio.file.Files;
  26. import java.security.KeyFactory;
  27. import java.security.NoSuchAlgorithmException;
  28. import java.security.interfaces.RSAPublicKey;
  29. import java.security.spec.InvalidKeySpecException;
  30. import java.security.spec.X509EncodedKeySpec;
  31. import java.util.Base64;
  32.  
  33. /**
  34.  * 资源服务器配置
  35.  */
  36. @Configuration
  37. @EnableWebFluxSecurity
  38. public class ResourceServerConfig {
  39.  
  40.     @Autowired
  41.     private CustomReactiveAuthorizationManager customReactiveAuthorizationManager;
  42.  
  43.     @Bean
  44.     public SecurityWebFilterChain securityWebFilterChain(ServerHttpSecurity http) throws NoSuchAlgorithmException, IOException, InvalidKeySpecException {
  45.         http.oauth2ResourceServer()
  46.                 .jwt()
  47.                     .jwtAuthenticationConverter(jwtAuthenticationConverter())
  48.                     .jwtDecoder(jwtDecoder())
  49.                     .and()
  50.                 // 认证成功后没有权限操作
  51.                 .accessDeniedHandler(new CustomServerAccessDeniedHandler())
  52.                 // 还没有认证时发生认证异常，比如token过期，token不合法
  53.                 .authenticationEntryPoint(new CustomServerAuthenticationEntryPoint())
  54.                 // 将一个字符串token转换成一个认证对象
  55.                 .bearerTokenConverter(new ServerBearerTokenAuthenticationConverter())
  56.                     .and()
  57.         .authorizeExchange()
  58.                 // 所有以 /auth/** 开头的请求全部放行
  59.                 .pathMatchers("/auth/**", "/favicon.ico").permitAll()
  60.                 // 所有的请求都交由此处进行权限判断处理
  61.                 .anyExchange()
  62.                     .access(customReactiveAuthorizationManager)
  63.                     .and()
  64.                 .exceptionHandling()
  65.                     .accessDeniedHandler(new CustomServerAccessDeniedHandler())
  66.                     .authenticationEntryPoint(new CustomServerAuthenticationEntryPoint())
  67.                     .and()
  68.                 .csrf()
  69.                     .disable()
  70.         .addFilterAfter(new TokenTransferFilter(), SecurityWebFiltersOrder.AUTHENTICATION);
  71.  
  72.         return http.build();
  73.     }
  74.  
  75.     /**
  76.      * 从jwt令牌中获取认证对象
  77.      */
  78.     public Converter<Jwt, ? extends Mono<? extends AbstractAuthenticationToken>> jwtAuthenticationConverter() {
  79.  
  80.         // 从jwt 中获取该令牌可以访问的权限
  81.         JwtGrantedAuthoritiesConverter authoritiesConverter = new JwtGrantedAuthoritiesConverter();
  82.         // 取消权限的前缀，默认会加上SCOPE_
  83.         authoritiesConverter.setAuthorityPrefix("");
  84.         // 从那个字段中获取权限
  85.         authoritiesConverter.setAuthoritiesClaimName("scope");
  86.  
  87.         JwtAuthenticationConverter jwtAuthenticationConverter = new JwtAuthenticationConverter();
  88.         // 获取 principal name
  89.         jwtAuthenticationConverter.setPrincipalClaimName("sub");
  90.         jwtAuthenticationConverter.setJwtGrantedAuthoritiesConverter(authoritiesConverter);
  91.  
  92.         return new ReactiveJwtAuthenticationConverterAdapter(jwtAuthenticationConverter);
  93.     }
  94.  
  95.     /**
  96.      * 解码jwt
  97.      */
  98.     public ReactiveJwtDecoder jwtDecoder() throws IOException, NoSuchAlgorithmException, InvalidKeySpecException {
  99.         Resource resource = new FileSystemResource("/Users/huan/code/study/idea/spring-cloud-alibaba-parent/gateway-oauth2/new-authoriza-server-public-key.pem");
  100.         String publicKeyStr = String.join("", Files.readAllLines(resource.getFile().toPath()));
  101.         byte[] publicKeyBytes = Base64.getDecoder().decode(publicKeyStr);
  102.         X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKeyBytes);
  103.         KeyFactory keyFactory = KeyFactory.getInstance("RSA");
  104.         RSAPublicKey rsaPublicKey = (RSAPublicKey) keyFactory.generatePublic(keySpec);
  105.  
  106.         return NimbusReactiveJwtDecoder.withPublicKey(rsaPublicKey)
  107.                 .signatureAlgorithm(SignatureAlgorithm.RS256)
  108.                 .build();
  109.     }
  110. }

7、网关yaml配置文件

  1. spring:
  2.   application:
  3.     name: gateway-auth
  4.   cloud:
  5.     nacos:
  6.       discovery:
  7.         server-addr: localhost:8847
  8.     gateway:
  9.       routes:
  10.         - id: user-provider
  11.           uri: lb://user-provider
  12.           predicates:
  13.             - Path=/user/**
  14.           filters:
  15.             - RewritePath=/user(?<segment>/?.*), $\{segment}
  16.     compatibility-verifier:
  17.       # 取消SpringCloud SpringCloudAlibaba SpringBoot 等的版本检查
  18.       enabled: false
  19. server:
  20.   port: 9203
  21. debug: true

六、演示

1、客户端 gateway 在认证服务器拥有的权限为 user.userInfo

85b4fe9e66feba38e92b2211f26a99d7.jpeg
客户端gateway拥有的权限

2、user-provider服务提供了一个api findAllUsers，它会返回 系统中存在的用户(假的数据) 和 解码后的token信息。

3、在网关层面，findAllUsers 需要的权限为 user.userInfo，正好 gateway这个客户端有这个权限，所以可以访问。

七、代码路径

https://gitee.com/huan1993/spring-cloud-alibaba-parent/tree/master/gateway-oauth2

欢迎加入我的知识星球，一起探讨架构，交流源码。加入方式，长按下方二维码噢：

3f0dc8bcb62e856753f0780f0942ea89.png

已在知识星球更新源码解析如下：

25782807e64f8e52c816111d9cd05130.jpeg

8c780e3b41825fd6cf176fec975c332f.jpeg

d80309c4cc9b017aa9969413a1f33ee8.jpeg

be99154ff8c28b7cf15a6eb50153c433.jpeg

最近更新《芋道 SpringBoot 2.X 入门》系列，已经 101 余篇，覆盖了 MyBatis、Redis、MongoDB、ES、分库分表、读写分离、SpringMVC、Webflux、权限、WebSocket、Dubbo、RabbitMQ、RocketMQ、Kafka、性能测试等等内容。

提供近 3W 行代码的 SpringBoot 示例，以及超 4W 行代码的电商微服务项目。

获取方式：点“在看”，关注公众号并回复 666 领取，更多内容陆续奉上。

  1. 文章有帮助的话，在看，转发吧。
  2. 谢谢支持哟 (*^__^*）
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/68898
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号